From 9d35ff73c4cbd75d4eecae4c8c0be467b2e994ce Mon Sep 17 00:00:00 2001 From: Dave Bartolomeo Date: Wed, 22 Jan 2020 00:15:30 -0700 Subject: [PATCH 1/6] C++/C#: Make escape analysis unsound by default When building SSA, we'll be assuming that stack variables do not escape, at least until we improve our alias analysis. I've added a new `IREscapeAnalysisConfiguration` class to allow the query to control this, and a new `UseSoundEscapeAnalysis.qll` module that can be imported to switch to the sound escape analysis. I've cloned the existing IR and SSA tests to have both sound and unsound versions. There were relatively few diffs in the IR dump tests, and the sanity tests still give the same results after one change described below. Assuming that stack variables do not escape exposed an existing bug where we do not emit an `Uninitialized` instruction for the temporary variables used by `return` statements and `throw` expressions, even if the initializer is a constructor call or array initializer. I've refactored the code for handling elements that initialize a variable to share a common base class. I added a test case for returning an object initialized by constructor call, and ensured that the IR diffs for the existing `throw` test cases are correct. --- config/identical-files.json | 8 + .../cpp/ir/implementation/IRConfiguration.qll | 19 + .../implementation/UseSoundEscapeAnalysis.qll | 9 + .../aliased_ssa/internal/AliasAnalysis.qll | 12 +- .../aliased_ssa/internal/PrintSSA.qll | 2 +- .../internal/TranslatedDeclarationEntry.qll | 83 +- .../raw/internal/TranslatedExpr.qll | 36 +- .../raw/internal/TranslatedInitialization.qll | 92 + .../raw/internal/TranslatedStmt.qll | 40 +- .../unaliased_ssa/internal/AliasAnalysis.qll | 12 +- .../unaliased_ssa/internal/PrintSSA.qll | 2 +- cpp/ql/test/library-tests/ir/escape/escape.ql | 1 + .../library-tests/ir/escape/ssa_escape.ql | 1 + .../library-tests/ir/ir/PrintAST.expected | 14 + .../ir/ir/aliased_ssa_ir.expected | 6200 +++++++++++++++++ .../library-tests/ir/ir/aliased_ssa_ir.qlref | 1 + .../library-tests/ir/ir/aliased_ssa_sanity.ql | 2 + .../ir/ir/aliased_ssa_sanity_unsound.expected | 26 + ...qlref => aliased_ssa_sanity_unsound.qlref} | 0 .../ir/ir/aliased_ssa_ssa_sanity.ql | 2 + .../aliased_ssa_ssa_sanity_unsound.expected | 2 + ...f => aliased_ssa_ssa_sanity_unsound.qlref} | 0 cpp/ql/test/library-tests/ir/ir/ir.cpp | 4 + .../test/library-tests/ir/ir/raw_ir.expected | 97 +- .../ir/ir/unaliased_ssa_ir.expected | 5926 ++++++++++++++++ .../ir/{ssa => ir}/unaliased_ssa_ir.qlref | 0 .../ir/ir/unaliased_ssa_sanity.ql | 2 + .../ir/unaliased_ssa_sanity_unsound.expected | 26 + ...ref => unaliased_ssa_sanity_unsound.qlref} | 0 .../ir/ir/unaliased_ssa_ssa_sanity.ql | 2 + .../unaliased_ssa_ssa_sanity_unsound.expected | 2 + ...=> unaliased_ssa_ssa_sanity_unsound.qlref} | 0 .../library-tests/ir/ssa/aliased_ssa_ir.ql | 6 + .../ir/ssa/aliased_ssa_ir_unsound.expected | 1082 +++ ..._ir.qlref => aliased_ssa_ir_unsound.qlref} | 0 .../ir/ssa/aliased_ssa_sanity.ql | 2 + .../ssa/aliased_ssa_sanity_unsound.expected | 22 + ...qlref => aliased_ssa_sanity_unsound.qlref} | 0 .../ir/ssa/aliased_ssa_ssa_sanity.ql | 2 + .../aliased_ssa_ssa_sanity_unsound.expected | 2 + ...f => aliased_ssa_ssa_sanity_unsound.qlref} | 0 .../library-tests/ir/ssa/unaliased_ssa_ir.ql | 6 + .../ir/ssa/unaliased_ssa_ir_unsound.expected | 1025 +++ .../ir/ssa/unaliased_ssa_ir_unsound.qlref | 1 + .../ir/ssa/unaliased_ssa_sanity.ql | 2 + .../ssa/unaliased_ssa_sanity_unsound.expected | 22 + ...ref => unaliased_ssa_sanity_unsound.qlref} | 0 .../ir/ssa/unaliased_ssa_ssa_sanity.ql | 2 + .../unaliased_ssa_ssa_sanity_unsound.expected | 2 + ...=> unaliased_ssa_ssa_sanity_unsound.qlref} | 0 .../ir/implementation/IRConfiguration.qll | 15 + .../implementation/UseSoundEscapeAnalysis.qll | 9 + .../unaliased_ssa/internal/PrintSSA.qll | 2 +- 53 files changed, 14654 insertions(+), 171 deletions(-) create mode 100644 cpp/ql/src/semmle/code/cpp/ir/implementation/UseSoundEscapeAnalysis.qll create mode 100644 cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.expected create mode 100644 cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.qlref create mode 100644 cpp/ql/test/library-tests/ir/ir/aliased_ssa_sanity.ql create mode 100644 cpp/ql/test/library-tests/ir/ir/aliased_ssa_sanity_unsound.expected rename cpp/ql/test/library-tests/ir/ir/{aliased_ssa_sanity.qlref => aliased_ssa_sanity_unsound.qlref} (100%) create mode 100644 cpp/ql/test/library-tests/ir/ir/aliased_ssa_ssa_sanity.ql create mode 100644 cpp/ql/test/library-tests/ir/ir/aliased_ssa_ssa_sanity_unsound.expected rename cpp/ql/test/library-tests/ir/ir/{aliased_ssa_ssa_sanity.qlref => aliased_ssa_ssa_sanity_unsound.qlref} (100%) create mode 100644 cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.expected rename cpp/ql/test/library-tests/ir/{ssa => ir}/unaliased_ssa_ir.qlref (100%) create mode 100644 cpp/ql/test/library-tests/ir/ir/unaliased_ssa_sanity.ql create mode 100644 cpp/ql/test/library-tests/ir/ir/unaliased_ssa_sanity_unsound.expected rename cpp/ql/test/library-tests/ir/ir/{unaliased_ssa_sanity.qlref => unaliased_ssa_sanity_unsound.qlref} (100%) create mode 100644 cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ssa_sanity.ql create mode 100644 cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ssa_sanity_unsound.expected rename cpp/ql/test/library-tests/ir/ir/{unaliased_ssa_ssa_sanity.qlref => unaliased_ssa_ssa_sanity_unsound.qlref} (100%) create mode 100644 cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir.ql create mode 100644 cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir_unsound.expected rename cpp/ql/test/library-tests/ir/ssa/{aliased_ssa_ir.qlref => aliased_ssa_ir_unsound.qlref} (100%) create mode 100644 cpp/ql/test/library-tests/ir/ssa/aliased_ssa_sanity.ql create mode 100644 cpp/ql/test/library-tests/ir/ssa/aliased_ssa_sanity_unsound.expected rename cpp/ql/test/library-tests/ir/ssa/{aliased_ssa_sanity.qlref => aliased_ssa_sanity_unsound.qlref} (100%) create mode 100644 cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ssa_sanity.ql create mode 100644 cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ssa_sanity_unsound.expected rename cpp/ql/test/library-tests/ir/ssa/{aliased_ssa_ssa_sanity.qlref => aliased_ssa_ssa_sanity_unsound.qlref} (100%) create mode 100644 cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir.ql create mode 100644 cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir_unsound.expected create mode 100644 cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir_unsound.qlref create mode 100644 cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_sanity.ql create mode 100644 cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_sanity_unsound.expected rename cpp/ql/test/library-tests/ir/ssa/{unaliased_ssa_sanity.qlref => unaliased_ssa_sanity_unsound.qlref} (100%) create mode 100644 cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ssa_sanity.ql create mode 100644 cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ssa_sanity_unsound.expected rename cpp/ql/test/library-tests/ir/ssa/{unaliased_ssa_ssa_sanity.qlref => unaliased_ssa_ssa_sanity_unsound.qlref} (100%) create mode 100644 csharp/ql/src/semmle/code/csharp/ir/implementation/UseSoundEscapeAnalysis.qll diff --git a/config/identical-files.json b/config/identical-files.json index 709f78868eb..e57bf00ca23 100644 --- a/config/identical-files.json +++ b/config/identical-files.json @@ -82,6 +82,14 @@ "cpp/ql/src/semmle/code/cpp/ir/implementation/IRType.qll", "csharp/ql/src/semmle/code/csharp/ir/implementation/IRType.qll" ], + "IR IRConfiguration": [ + "cpp/ql/src/semmle/code/cpp/ir/implementation/IRConfiguration.qll", + "csharp/ql/src/semmle/code/csharp/ir/implementation/IRConfiguration.qll" + ], + "IR UseSoundEscapeAnalysis": [ + "cpp/ql/src/semmle/code/cpp/ir/implementation/UseSoundEscapeAnalysis.qll", + "csharp/ql/src/semmle/code/csharp/ir/implementation/UseSoundEscapeAnalysis.qll" + ], "IR Operand Tag": [ "cpp/ql/src/semmle/code/cpp/ir/implementation/internal/OperandTag.qll", "csharp/ql/src/semmle/code/csharp/ir/implementation/internal/OperandTag.qll" diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/IRConfiguration.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/IRConfiguration.qll index c7133c21798..c0a489ef0c6 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/IRConfiguration.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/IRConfiguration.qll @@ -1,3 +1,7 @@ +/** + * Module used to configure the IR generation process. + */ + private import internal.IRConfigurationInternal private newtype TIRConfiguration = MkIRConfiguration() @@ -13,3 +17,18 @@ class IRConfiguration extends TIRConfiguration { */ predicate shouldCreateIRForFunction(Language::Function func) { any() } } + +private newtype TIREscapeAnalysisConfiguration = MkIREscapeAnalysisConfiguration() + +/** + * The query can extend this class to control what escape analysis is used when generating SSA. + */ +class IREscapeAnalysisConfiguration extends TIREscapeAnalysisConfiguration { + string toString() { result = "IREscapeAnalysisConfiguration" } + + /** + * Holds if the escape analysis done by SSA construction should be sound. By default, the SSA is + * built assuming that no variable's address ever escapes. + */ + predicate useSoundEscapeAnalysis() { none() } +} diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/UseSoundEscapeAnalysis.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/UseSoundEscapeAnalysis.qll new file mode 100644 index 00000000000..b9b1dc243b1 --- /dev/null +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/UseSoundEscapeAnalysis.qll @@ -0,0 +1,9 @@ +import IRConfiguration + +/** + * Overrides the default IR configuration to use sound escape analysis, instead of assuming that + * variable addresses never escape. + */ +class SoundEscapeAnalysisConfiguration extends IREscapeAnalysisConfiguration { + override predicate useSoundEscapeAnalysis() { any() } +} diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/AliasAnalysis.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/AliasAnalysis.qll index 18e449294f8..85b66cdca19 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/AliasAnalysis.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/AliasAnalysis.qll @@ -2,6 +2,7 @@ private import AliasAnalysisInternal private import cpp private import InputIR private import semmle.code.cpp.ir.internal.IntegerConstant as Ints +private import semmle.code.cpp.ir.implementation.IRConfiguration private import semmle.code.cpp.models.interfaces.Alias private class IntValue = Ints::IntValue; @@ -277,9 +278,16 @@ private predicate automaticVariableAddressEscapes(IRAutomaticVariable var) { * analysis. */ predicate variableAddressEscapes(IRVariable var) { - automaticVariableAddressEscapes(var.(IRAutomaticVariable)) + exists(IREscapeAnalysisConfiguration config | + config.useSoundEscapeAnalysis() and + ( + automaticVariableAddressEscapes(var.(IRAutomaticVariable)) + ) + ) or - // All variables with static storage duration have their address escape. + // All variables with static storage duration have their address escape, even when escape analysis + // is allowed to be unsound. Otherwise, we won't have a definition for any non-escaped global + // variable. Normally, we rely on `AliasedDefinition` to handle that. not var instanceof IRAutomaticVariable } diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/PrintSSA.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/PrintSSA.qll index 23121523a6b..94470fe8584 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/PrintSSA.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/PrintSSA.qll @@ -107,7 +107,7 @@ class PropertyProvider extends IRPropertyProvider { exists( MemoryLocation useLocation, IRBlock predBlock, IRBlock defBlock, int defIndex, Overlap overlap | - hasPhiOperandDefinition(_, useLocation, block, predBlock, defBlock, defIndex, overlap) and + hasPhiOperandDefinition(_, useLocation, block, predBlock, defBlock, defIndex) and key = "PhiUse[" + useLocation.toString() + " from " + predBlock.getDisplayIndex().toString() + "]" and result = defBlock.getDisplayIndex().toString() + "_" + defIndex + " (" + overlap.toString() + diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedDeclarationEntry.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedDeclarationEntry.qll index 87fd781fd95..fa2d3da59a4 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedDeclarationEntry.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedDeclarationEntry.qll @@ -43,93 +43,34 @@ abstract class TranslatedDeclarationEntry extends TranslatedElement, TTranslated * Represents the IR translation of the declaration of a local variable, * including its initialization, if any. */ -abstract class TranslatedVariableDeclaration extends TranslatedElement, InitializationContext { +abstract class TranslatedLocalVariableDeclaration extends TranslatedVariableInitialization { /** * Gets the local variable being declared. */ abstract LocalVariable getVariable(); - override TranslatedElement getChild(int id) { id = 0 and result = getInitialization() } + final override Type getTargetType() { result = getVariableType(getVariable()) } - override Instruction getFirstInstruction() { - result = getInstruction(InitializerVariableAddressTag()) - } - - override predicate hasInstruction(Opcode opcode, InstructionTag tag, CppType resultType) { - tag = InitializerVariableAddressTag() and - opcode instanceof Opcode::VariableAddress and - resultType = getTypeForGLValue(getVariableType(getVariable())) - or - hasUninitializedInstruction() and - tag = InitializerStoreTag() and - opcode instanceof Opcode::Uninitialized and - resultType = getTypeForPRValue(getVariableType(getVariable())) - } - - override Instruction getInstructionSuccessor(InstructionTag tag, EdgeKind kind) { - ( - tag = InitializerVariableAddressTag() and - kind instanceof GotoEdge and - if hasUninitializedInstruction() - then result = getInstruction(InitializerStoreTag()) - else result = getInitialization().getFirstInstruction() - ) - or - hasUninitializedInstruction() and - kind instanceof GotoEdge and - tag = InitializerStoreTag() and - ( - result = getInitialization().getFirstInstruction() - or - not exists(getInitialization()) and result = getParent().getChildSuccessor(this) - ) - } - - override Instruction getChildSuccessor(TranslatedElement child) { - child = getInitialization() and result = getParent().getChildSuccessor(this) - } - - override IRVariable getInstructionVariable(InstructionTag tag) { - ( - tag = InitializerVariableAddressTag() - or - hasUninitializedInstruction() and tag = InitializerStoreTag() - ) and - result = getIRUserVariable(getFunction(), getVariable()) - } - - override Instruction getInstructionOperand(InstructionTag tag, OperandTag operandTag) { - hasUninitializedInstruction() and - tag = InitializerStoreTag() and - operandTag instanceof AddressOperandTag and - result = getInstruction(InitializerVariableAddressTag()) - } - - override Instruction getTargetAddress() { - result = getInstruction(InitializerVariableAddressTag()) - } - - override Type getTargetType() { result = getVariableType(getVariable()) } - - private TranslatedInitialization getInitialization() { + final override TranslatedInitialization getInitialization() { result = getTranslatedInitialization(getVariable() .getInitializer() .getExpr() .getFullyConverted()) } - private predicate hasUninitializedInstruction() { - not exists(getInitialization()) or - getInitialization() instanceof TranslatedListInitialization or - getInitialization() instanceof TranslatedConstructorInitialization or - getInitialization().(TranslatedStringLiteralInitialization).zeroInitRange(_, _) + final override Instruction getInitializationSuccessor() { + result = getParent().getChildSuccessor(this) + } + + final override IRVariable getIRVariable() { + result = getIRUserVariable(getFunction(), getVariable()) } } /** * Represents the IR translation of a local variable declaration within a declaration statement. */ -class TranslatedVariableDeclarationEntry extends TranslatedVariableDeclaration, +class TranslatedVariableDeclarationEntry extends TranslatedLocalVariableDeclaration, TranslatedDeclarationEntry { LocalVariable var; @@ -151,7 +92,7 @@ TranslatedRangeBasedForVariableDeclaration getTranslatedRangeBasedForVariableDec /** * Represents the IR translation of a compiler-generated variable in a range-based `for` loop. */ -class TranslatedRangeBasedForVariableDeclaration extends TranslatedVariableDeclaration, +class TranslatedRangeBasedForVariableDeclaration extends TranslatedLocalVariableDeclaration, TTranslatedRangeBasedForVariableDeclaration { RangeBasedForStmt forStmt; LocalVariable var; @@ -181,7 +122,7 @@ TranslatedConditionDecl getTranslatedConditionDecl(ConditionDeclExpr expr) { * } * ``` */ -class TranslatedConditionDecl extends TranslatedVariableDeclaration, TTranslatedConditionDecl { +class TranslatedConditionDecl extends TranslatedLocalVariableDeclaration, TTranslatedConditionDecl { ConditionDeclExpr conditionDeclExpr; TranslatedConditionDecl() { this = TTranslatedConditionDecl(conditionDeclExpr) } 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 9db42c742ac..384d724eef9 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 @@ -1932,47 +1932,33 @@ abstract class TranslatedThrowExpr extends TranslatedNonConstantExpr { * IR translation of a `throw` expression with an argument * (e.g. `throw std::bad_alloc()`). */ -class TranslatedThrowValueExpr extends TranslatedThrowExpr, InitializationContext { +class TranslatedThrowValueExpr extends TranslatedThrowExpr, TranslatedVariableInitialization { TranslatedThrowValueExpr() { not expr instanceof ReThrowExpr } - override TranslatedElement getChild(int id) { id = 0 and result = getInitialization() } - - override Instruction getFirstInstruction() { - result = getInstruction(InitializerVariableAddressTag()) - } - override predicate hasInstruction(Opcode opcode, InstructionTag tag, CppType resultType) { TranslatedThrowExpr.super.hasInstruction(opcode, tag, resultType) or - tag = InitializerVariableAddressTag() and - opcode instanceof Opcode::VariableAddress and - resultType = getTypeForGLValue(getExceptionType()) + TranslatedVariableInitialization.super.hasInstruction(opcode, tag, resultType) } override Instruction getInstructionSuccessor(InstructionTag tag, EdgeKind kind) { result = TranslatedThrowExpr.super.getInstructionSuccessor(tag, kind) or - tag = InitializerVariableAddressTag() and - result = getInitialization().getFirstInstruction() and - kind instanceof GotoEdge + result = TranslatedVariableInitialization.super.getInstructionSuccessor(tag, kind) } - override Instruction getChildSuccessor(TranslatedElement child) { - child = getInitialization() and + final override Instruction getInitializationSuccessor() { result = getInstruction(ThrowTag()) } - override IRVariable getInstructionVariable(InstructionTag tag) { - tag = InitializerVariableAddressTag() and - result = getIRTempVariable(expr, ThrowTempVar()) - } - final override predicate hasTempVariable(TempVariableTag tag, CppType type) { tag = ThrowTempVar() and type = getTypeForPRValue(getExceptionType()) } final override Instruction getInstructionOperand(InstructionTag tag, OperandTag operandTag) { + result = TranslatedVariableInitialization.super.getInstructionOperand(tag, operandTag) + or tag = ThrowTag() and ( operandTag instanceof AddressOperandTag and @@ -1989,16 +1975,16 @@ class TranslatedThrowValueExpr extends TranslatedThrowExpr, InitializationContex result = getTypeForPRValue(getExceptionType()) } - override Instruction getTargetAddress() { - result = getInstruction(InitializerVariableAddressTag()) - } - override Type getTargetType() { result = getExceptionType() } - TranslatedInitialization getInitialization() { + final override TranslatedInitialization getInitialization() { result = getTranslatedInitialization(expr.getExpr().getFullyConverted()) } + final override IRVariable getIRVariable() { + result = getIRTempVariable(expr, ThrowTempVar()) + } + final override Opcode getThrowOpcode() { result instanceof Opcode::ThrowValue } private Type getExceptionType() { result = expr.getType() } 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 609f8276640..4c86f0b8194 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 @@ -30,6 +30,98 @@ abstract class InitializationContext extends TranslatedElement { abstract Type getTargetType(); } +/** + * Base class for any element that initializes a stack variable. Examples include local variable + * declarations, `return` statements, and `throw` expressions. + */ +abstract class TranslatedVariableInitialization extends TranslatedElement, InitializationContext { + final override TranslatedElement getChild(int id) { id = 0 and result = getInitialization() } + + final override Instruction getFirstInstruction() { + result = getInstruction(InitializerVariableAddressTag()) + } + + override predicate hasInstruction(Opcode opcode, InstructionTag tag, CppType resultType) { + tag = InitializerVariableAddressTag() and + opcode instanceof Opcode::VariableAddress and + resultType = getTypeForGLValue(getTargetType()) + or + hasUninitializedInstruction() and + tag = InitializerStoreTag() and + opcode instanceof Opcode::Uninitialized and + resultType = getTypeForPRValue(getTargetType()) + } + + override Instruction getInstructionSuccessor(InstructionTag tag, EdgeKind kind) { + ( + tag = InitializerVariableAddressTag() and + kind instanceof GotoEdge and + if hasUninitializedInstruction() + then result = getInstruction(InitializerStoreTag()) + else result = getInitialization().getFirstInstruction() + ) + or + hasUninitializedInstruction() and + kind instanceof GotoEdge and + tag = InitializerStoreTag() and + ( + result = getInitialization().getFirstInstruction() + or + not exists(getInitialization()) and result = getInitializationSuccessor() + ) + } + + final override Instruction getChildSuccessor(TranslatedElement child) { + child = getInitialization() and result = getInitializationSuccessor() + } + + override Instruction getInstructionOperand(InstructionTag tag, OperandTag operandTag) { + hasUninitializedInstruction() and + tag = InitializerStoreTag() and + operandTag instanceof AddressOperandTag and + result = getInstruction(InitializerVariableAddressTag()) + } + + final override IRVariable getInstructionVariable(InstructionTag tag) { + ( + tag = InitializerVariableAddressTag() + or + hasUninitializedInstruction() and tag = InitializerStoreTag() + ) and + result = getIRVariable() + } + + final override Instruction getTargetAddress() { + result = getInstruction(InitializerVariableAddressTag()) + } + + /** + * Get the initialization for the variable. + */ + abstract TranslatedInitialization getInitialization(); + + /** + * Get the `IRVariable` to be initialized. This may be an `IRTempVariable`. + */ + abstract IRVariable getIRVariable(); + + /** + * Gets the `Instruction` to be executed immediately after the initialization. + */ + abstract Instruction getInitializationSuccessor(); + + /** + * Holds if this initialization requires an `Uninitialized` instruction to be emitted before + * evaluating the initializer. + */ + final predicate hasUninitializedInstruction() { + not exists(getInitialization()) or + getInitialization() instanceof TranslatedListInitialization or + getInitialization() instanceof TranslatedConstructorInitialization or + getInitialization().(TranslatedStringLiteralInitialization).zeroInitRange(_, _) + } +} + /** * Represents the IR translation of any initialization, whether from an * initializer list or from a direct initializer. diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedStmt.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedStmt.qll index 62cbba8604b..7458f2e104d 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedStmt.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedStmt.qll @@ -130,46 +130,22 @@ abstract class TranslatedReturnStmt extends TranslatedStmt { } } -class TranslatedReturnValueStmt extends TranslatedReturnStmt, InitializationContext { +class TranslatedReturnValueStmt extends TranslatedReturnStmt, TranslatedVariableInitialization { TranslatedReturnValueStmt() { stmt.hasExpr() } - override TranslatedElement getChild(int id) { id = 0 and result = getInitialization() } - - override Instruction getFirstInstruction() { - result = getInstruction(InitializerVariableAddressTag()) - } - - override predicate hasInstruction(Opcode opcode, InstructionTag tag, CppType resultType) { - tag = InitializerVariableAddressTag() and - opcode instanceof Opcode::VariableAddress and - resultType = getTypeForGLValue(getEnclosingFunction().getReturnType()) - } - - override Instruction getInstructionSuccessor(InstructionTag tag, EdgeKind kind) { - tag = InitializerVariableAddressTag() and - result = getInitialization().getFirstInstruction() and - kind instanceof GotoEdge - } - - override Instruction getChildSuccessor(TranslatedElement child) { - child = getInitialization() and + final override Instruction getInitializationSuccessor() { result = getEnclosingFunction().getReturnSuccessorInstruction() } - override IRVariable getInstructionVariable(InstructionTag tag) { - tag = InitializerVariableAddressTag() and - result = getEnclosingFunction().getReturnVariable() - } + final override Type getTargetType() { result = getEnclosingFunction().getReturnType() } - override Instruction getTargetAddress() { - result = getInstruction(InitializerVariableAddressTag()) - } - - override Type getTargetType() { result = getEnclosingFunction().getReturnType() } - - TranslatedInitialization getInitialization() { + final override TranslatedInitialization getInitialization() { result = getTranslatedInitialization(stmt.getExpr().getFullyConverted()) } + + final override IRVariable getIRVariable() { + result = getEnclosingFunction().getReturnVariable() + } } class TranslatedReturnVoidStmt extends TranslatedReturnStmt { diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/AliasAnalysis.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/AliasAnalysis.qll index 18e449294f8..85b66cdca19 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/AliasAnalysis.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/AliasAnalysis.qll @@ -2,6 +2,7 @@ private import AliasAnalysisInternal private import cpp private import InputIR private import semmle.code.cpp.ir.internal.IntegerConstant as Ints +private import semmle.code.cpp.ir.implementation.IRConfiguration private import semmle.code.cpp.models.interfaces.Alias private class IntValue = Ints::IntValue; @@ -277,9 +278,16 @@ private predicate automaticVariableAddressEscapes(IRAutomaticVariable var) { * analysis. */ predicate variableAddressEscapes(IRVariable var) { - automaticVariableAddressEscapes(var.(IRAutomaticVariable)) + exists(IREscapeAnalysisConfiguration config | + config.useSoundEscapeAnalysis() and + ( + automaticVariableAddressEscapes(var.(IRAutomaticVariable)) + ) + ) or - // All variables with static storage duration have their address escape. + // All variables with static storage duration have their address escape, even when escape analysis + // is allowed to be unsound. Otherwise, we won't have a definition for any non-escaped global + // variable. Normally, we rely on `AliasedDefinition` to handle that. not var instanceof IRAutomaticVariable } diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/PrintSSA.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/PrintSSA.qll index 23121523a6b..94470fe8584 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/PrintSSA.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/PrintSSA.qll @@ -107,7 +107,7 @@ class PropertyProvider extends IRPropertyProvider { exists( MemoryLocation useLocation, IRBlock predBlock, IRBlock defBlock, int defIndex, Overlap overlap | - hasPhiOperandDefinition(_, useLocation, block, predBlock, defBlock, defIndex, overlap) and + hasPhiOperandDefinition(_, useLocation, block, predBlock, defBlock, defIndex) and key = "PhiUse[" + useLocation.toString() + " from " + predBlock.getDisplayIndex().toString() + "]" and result = defBlock.getDisplayIndex().toString() + "_" + defIndex + " (" + overlap.toString() + diff --git a/cpp/ql/test/library-tests/ir/escape/escape.ql b/cpp/ql/test/library-tests/ir/escape/escape.ql index 25475252d49..109ff260b7d 100644 --- a/cpp/ql/test/library-tests/ir/escape/escape.ql +++ b/cpp/ql/test/library-tests/ir/escape/escape.ql @@ -1,6 +1,7 @@ import default import semmle.code.cpp.ir.implementation.unaliased_ssa.internal.AliasAnalysis import semmle.code.cpp.ir.implementation.raw.IR +import semmle.code.cpp.ir.implementation.UseSoundEscapeAnalysis predicate shouldEscape(IRAutomaticUserVariable var) { exists(string name | diff --git a/cpp/ql/test/library-tests/ir/escape/ssa_escape.ql b/cpp/ql/test/library-tests/ir/escape/ssa_escape.ql index 2ef33ae749f..8025a455fc9 100644 --- a/cpp/ql/test/library-tests/ir/escape/ssa_escape.ql +++ b/cpp/ql/test/library-tests/ir/escape/ssa_escape.ql @@ -1,6 +1,7 @@ import default import semmle.code.cpp.ir.implementation.aliased_ssa.internal.AliasAnalysis import semmle.code.cpp.ir.implementation.unaliased_ssa.IR +import semmle.code.cpp.ir.implementation.UseSoundEscapeAnalysis predicate shouldEscape(IRAutomaticUserVariable var) { exists(string name | diff --git a/cpp/ql/test/library-tests/ir/ir/PrintAST.expected b/cpp/ql/test/library-tests/ir/ir/PrintAST.expected index aa56b05163f..7778ebb76c0 100644 --- a/cpp/ql/test/library-tests/ir/ir/PrintAST.expected +++ b/cpp/ql/test/library-tests/ir/ir/PrintAST.expected @@ -8056,6 +8056,20 @@ ir.cpp: # 1166| 0: [VariableAccess] y # 1166| Type = [IntType] int # 1166| ValueCategory = prvalue(load) +# 1169| [TopLevelFunction] String ReturnObjectImpl() +# 1169| params: +# 1169| body: [Block] { ... } +# 1170| 0: [ReturnStmt] return ... +# 1170| 0: [ConstructorCall] call to String +# 1170| Type = [Struct] String +# 1170| ValueCategory = prvalue +# 1170| 0: [ArrayToPointerConversion] array to pointer conversion +# 1170| Type = [PointerType] const char * +# 1170| ValueCategory = prvalue +# 1170| expr: foo +# 1170| Type = [ArrayType] const char[4] +# 1170| Value = [StringLiteral] "foo" +# 1170| ValueCategory = lvalue perf-regression.cpp: # 4| [CopyAssignmentOperator] Big& Big::operator=(Big const&) # 4| params: 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 new file mode 100644 index 00000000000..be344e731a8 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.expected @@ -0,0 +1,6200 @@ +bad_asts.cpp: +# 9| int Bad::S::MemberFunction(int) +# 9| Block 0 +# 9| v9_1(void) = EnterFunction : +# 9| m9_2(unknown) = AliasedDefinition : +# 9| mu9_3(unknown) = UnmodeledDefinition : +# 9| r9_4(glval) = InitializeThis : +# 9| r9_5(glval) = VariableAddress[y] : +# 9| m9_6(int) = InitializeParameter[y] : &:r9_5 +# 10| r10_1(glval) = VariableAddress[#return] : +# 10| r10_2(int) = Constant[6] : +#-----| r0_1(S *) = CopyValue : r9_4 +# 10| r10_3(glval) = FieldAddress[x] : r0_1 +# 10| r10_4(int) = Load : &:r10_3, ~m9_2 +# 10| r10_5(int) = Add : r10_2, r10_4 +# 10| r10_6(glval) = VariableAddress[y] : +# 10| r10_7(int) = Load : &:r10_6, m9_6 +# 10| r10_8(int) = Add : r10_5, r10_7 +# 10| m10_9(int) = Store : &:r10_1, r10_8 +# 9| r9_7(glval) = VariableAddress[#return] : +# 9| v9_8(void) = ReturnValue : &:r9_7, m10_9 +# 9| v9_9(void) = UnmodeledUse : mu* +# 9| v9_10(void) = AliasedUse : ~m9_2 +# 9| v9_11(void) = ExitFunction : + +# 14| void Bad::CallBadMemberFunction() +# 14| Block 0 +# 14| v14_1(void) = EnterFunction : +# 14| m14_2(unknown) = AliasedDefinition : +# 14| mu14_3(unknown) = UnmodeledDefinition : +# 15| r15_1(glval) = VariableAddress[s] : +# 15| m15_2(S) = Uninitialized[s] : &:r15_1 +# 15| r15_3(glval) = FieldAddress[x] : r15_1 +# 15| r15_4(int) = Constant[0] : +# 15| m15_5(int) = Store : &:r15_3, r15_4 +# 16| r16_1(glval) = VariableAddress[s] : +# 16| r16_2(glval) = FunctionAddress[MemberFunction] : +# 16| r16_3(int) = Constant[1] : +# 16| r16_4(int) = Call : func:r16_2, this:r16_1, 0:r16_3 +# 16| m16_5(unknown) = ^CallSideEffect : ~m14_2 +# 16| m16_6(unknown) = Chi : total:m14_2, partial:m16_5 +# 16| v16_7(void) = ^BufferReadSideEffect[-1] : &:r16_1, ~m15_5 +# 16| m16_8(S) = ^IndirectMayWriteSideEffect[-1] : &:r16_1 +# 16| m16_9(S) = Chi : total:m15_5, partial:m16_8 +# 17| v17_1(void) = NoOp : +# 14| v14_4(void) = ReturnVoid : +# 14| v14_5(void) = UnmodeledUse : mu* +# 14| v14_6(void) = AliasedUse : ~m16_6 +# 14| v14_7(void) = ExitFunction : + +# 22| void Bad::Point::Point() +# 22| Block 0 +# 22| v22_1(void) = EnterFunction : +# 22| m22_2(unknown) = AliasedDefinition : +# 22| mu22_3(unknown) = UnmodeledDefinition : +# 22| r22_4(glval) = InitializeThis : +# 23| v23_1(void) = NoOp : +# 22| v22_5(void) = ReturnVoid : +# 22| v22_6(void) = UnmodeledUse : mu* +# 22| v22_7(void) = AliasedUse : ~m22_2 +# 22| v22_8(void) = ExitFunction : + +# 26| void Bad::CallCopyConstructor(Bad::Point const&) +# 26| Block 0 +# 26| v26_1(void) = EnterFunction : +# 26| m26_2(unknown) = AliasedDefinition : +# 26| mu26_3(unknown) = UnmodeledDefinition : +# 26| r26_4(glval) = VariableAddress[a] : +# 26| m26_5(Point &) = InitializeParameter[a] : &:r26_4 +# 26| r26_6(Point &) = Load : &:r26_4, m26_5 +# 26| m26_7(unknown) = InitializeIndirection[a] : &:r26_6 +# 26| m26_8(unknown) = Chi : total:m26_2, partial:m26_7 +# 27| r27_1(glval) = VariableAddress[b] : +# 27| r27_2(glval) = VariableAddress[a] : +# 27| r27_3(Point &) = Load : &:r27_2, m26_5 +# 27| r27_4(glval) = CopyValue : r27_3 +# 27| r27_5(glval) = Convert : r27_4 +# 27| r27_6(Point) = Load : &:r27_5, ~m26_8 +# 27| m27_7(Point) = Store : &:r27_1, r27_6 +# 28| v28_1(void) = NoOp : +# 26| v26_9(void) = ReturnIndirection : &:r26_6, ~m26_8 +# 26| v26_10(void) = ReturnVoid : +# 26| v26_11(void) = UnmodeledUse : mu* +# 26| v26_12(void) = AliasedUse : ~m26_8 +# 26| v26_13(void) = ExitFunction : + +# 30| void Bad::errorExpr() +# 30| Block 0 +# 30| v30_1(void) = EnterFunction : +# 30| m30_2(unknown) = AliasedDefinition : +# 30| mu30_3(unknown) = UnmodeledDefinition : +# 31| r31_1(glval) = VariableAddress[intref] : +# 31| r31_2(error) = Error : +# 31| m31_3(int &) = Store : &:r31_1, r31_2 +# 32| r32_1(glval) = VariableAddress[x] : +# 32| r32_2(error) = Error : +# 32| m32_3(int) = Store : &:r32_1, r32_2 +#-----| r0_1(glval) = Error : +#-----| r0_2(error) = Load : &:r0_1, ~m30_2 +# 33| r33_1(glval) = VariableAddress[x] : +# 33| m33_2(int) = Store : &:r33_1, r0_2 +# 34| v34_1(void) = NoOp : +# 30| v30_4(void) = ReturnVoid : +# 30| v30_5(void) = UnmodeledUse : mu* +# 30| v30_6(void) = AliasedUse : ~m30_2 +# 30| v30_7(void) = ExitFunction : + +clang.cpp: +# 5| int* globalIntAddress() +# 5| Block 0 +# 5| v5_1(void) = EnterFunction : +# 5| m5_2(unknown) = AliasedDefinition : +# 5| mu5_3(unknown) = UnmodeledDefinition : +# 6| r6_1(glval) = VariableAddress[#return] : +# 6| r6_2(glval) = VariableAddress[globalInt] : +# 6| r6_3(int *) = CopyValue : r6_2 +# 6| m6_4(int *) = Store : &:r6_1, r6_3 +# 5| r5_4(glval) = VariableAddress[#return] : +# 5| v5_5(void) = ReturnValue : &:r5_4, m6_4 +# 5| v5_6(void) = UnmodeledUse : mu* +# 5| v5_7(void) = AliasedUse : ~m5_2 +# 5| v5_8(void) = ExitFunction : + +ir.cpp: +# 1| void Constants() +# 1| Block 0 +# 1| v1_1(void) = EnterFunction : +# 1| m1_2(unknown) = AliasedDefinition : +# 1| mu1_3(unknown) = UnmodeledDefinition : +# 2| r2_1(glval) = VariableAddress[c_i] : +# 2| r2_2(char) = Constant[1] : +# 2| m2_3(char) = Store : &:r2_1, r2_2 +# 3| r3_1(glval) = VariableAddress[c_c] : +# 3| r3_2(char) = Constant[65] : +# 3| m3_3(char) = Store : &:r3_1, r3_2 +# 5| r5_1(glval) = VariableAddress[sc_i] : +# 5| r5_2(signed char) = Constant[-1] : +# 5| m5_3(signed char) = Store : &:r5_1, r5_2 +# 6| r6_1(glval) = VariableAddress[sc_c] : +# 6| r6_2(signed char) = Constant[65] : +# 6| m6_3(signed char) = Store : &:r6_1, r6_2 +# 8| r8_1(glval) = VariableAddress[uc_i] : +# 8| r8_2(unsigned char) = Constant[5] : +# 8| m8_3(unsigned char) = Store : &:r8_1, r8_2 +# 9| r9_1(glval) = VariableAddress[uc_c] : +# 9| r9_2(unsigned char) = Constant[65] : +# 9| m9_3(unsigned char) = Store : &:r9_1, r9_2 +# 11| r11_1(glval) = VariableAddress[s] : +# 11| r11_2(short) = Constant[5] : +# 11| m11_3(short) = Store : &:r11_1, r11_2 +# 12| r12_1(glval) = VariableAddress[us] : +# 12| r12_2(unsigned short) = Constant[5] : +# 12| m12_3(unsigned short) = Store : &:r12_1, r12_2 +# 14| r14_1(glval) = VariableAddress[i] : +# 14| r14_2(int) = Constant[5] : +# 14| m14_3(int) = Store : &:r14_1, r14_2 +# 15| r15_1(glval) = VariableAddress[ui] : +# 15| r15_2(unsigned int) = Constant[5] : +# 15| m15_3(unsigned int) = Store : &:r15_1, r15_2 +# 17| r17_1(glval) = VariableAddress[l] : +# 17| r17_2(long) = Constant[5] : +# 17| m17_3(long) = Store : &:r17_1, r17_2 +# 18| r18_1(glval) = VariableAddress[ul] : +# 18| r18_2(unsigned long) = Constant[5] : +# 18| m18_3(unsigned long) = Store : &:r18_1, r18_2 +# 20| r20_1(glval) = VariableAddress[ll_i] : +# 20| r20_2(long long) = Constant[5] : +# 20| m20_3(long long) = Store : &:r20_1, r20_2 +# 21| r21_1(glval) = VariableAddress[ll_ll] : +# 21| r21_2(long long) = Constant[5] : +# 21| m21_3(long long) = Store : &:r21_1, r21_2 +# 22| r22_1(glval) = VariableAddress[ull_i] : +# 22| r22_2(unsigned long long) = Constant[5] : +# 22| m22_3(unsigned long long) = Store : &:r22_1, r22_2 +# 23| r23_1(glval) = VariableAddress[ull_ull] : +# 23| r23_2(unsigned long long) = Constant[5] : +# 23| m23_3(unsigned long long) = Store : &:r23_1, r23_2 +# 25| r25_1(glval) = VariableAddress[b_t] : +# 25| r25_2(bool) = Constant[1] : +# 25| m25_3(bool) = Store : &:r25_1, r25_2 +# 26| r26_1(glval) = VariableAddress[b_f] : +# 26| r26_2(bool) = Constant[0] : +# 26| m26_3(bool) = Store : &:r26_1, r26_2 +# 28| r28_1(glval) = VariableAddress[wc_i] : +# 28| r28_2(wchar_t) = Constant[5] : +# 28| m28_3(wchar_t) = Store : &:r28_1, r28_2 +# 29| r29_1(glval) = VariableAddress[wc_c] : +# 29| r29_2(wchar_t) = Constant[65] : +# 29| m29_3(wchar_t) = Store : &:r29_1, r29_2 +# 31| r31_1(glval) = VariableAddress[c16] : +# 31| r31_2(char16_t) = Constant[65] : +# 31| m31_3(char16_t) = Store : &:r31_1, r31_2 +# 32| r32_1(glval) = VariableAddress[c32] : +# 32| r32_2(char32_t) = Constant[65] : +# 32| m32_3(char32_t) = Store : &:r32_1, r32_2 +# 34| r34_1(glval) = VariableAddress[f_i] : +# 34| r34_2(float) = Constant[1.0] : +# 34| m34_3(float) = Store : &:r34_1, r34_2 +# 35| r35_1(glval) = VariableAddress[f_f] : +# 35| r35_2(float) = Constant[1.0] : +# 35| m35_3(float) = Store : &:r35_1, r35_2 +# 36| r36_1(glval) = VariableAddress[f_d] : +# 36| r36_2(float) = Constant[1.0] : +# 36| m36_3(float) = Store : &:r36_1, r36_2 +# 38| r38_1(glval) = VariableAddress[d_i] : +# 38| r38_2(double) = Constant[1.0] : +# 38| m38_3(double) = Store : &:r38_1, r38_2 +# 39| r39_1(glval) = VariableAddress[d_f] : +# 39| r39_2(double) = Constant[1.0] : +# 39| m39_3(double) = Store : &:r39_1, r39_2 +# 40| r40_1(glval) = VariableAddress[d_d] : +# 40| r40_2(double) = Constant[1.0] : +# 40| m40_3(double) = Store : &:r40_1, r40_2 +# 41| v41_1(void) = NoOp : +# 1| v1_4(void) = ReturnVoid : +# 1| v1_5(void) = UnmodeledUse : mu* +# 1| v1_6(void) = AliasedUse : ~m1_2 +# 1| v1_7(void) = ExitFunction : + +# 43| void Foo() +# 43| Block 0 +# 43| v43_1(void) = EnterFunction : +# 43| m43_2(unknown) = AliasedDefinition : +# 43| mu43_3(unknown) = UnmodeledDefinition : +# 44| r44_1(glval) = VariableAddress[x] : +# 44| r44_2(int) = Constant[17] : +# 44| m44_3(int) = Store : &:r44_1, r44_2 +# 45| r45_1(glval) = VariableAddress[y] : +# 45| r45_2(short) = Constant[7] : +# 45| m45_3(short) = Store : &:r45_1, r45_2 +# 46| r46_1(glval) = VariableAddress[x] : +# 46| r46_2(int) = Load : &:r46_1, m44_3 +# 46| r46_3(glval) = VariableAddress[y] : +# 46| r46_4(short) = Load : &:r46_3, m45_3 +# 46| r46_5(int) = Convert : r46_4 +# 46| r46_6(int) = Add : r46_2, r46_5 +# 46| r46_7(short) = Convert : r46_6 +# 46| r46_8(glval) = VariableAddress[y] : +# 46| m46_9(short) = Store : &:r46_8, r46_7 +# 47| r47_1(glval) = VariableAddress[x] : +# 47| r47_2(int) = Load : &:r47_1, m44_3 +# 47| r47_3(glval) = VariableAddress[y] : +# 47| r47_4(short) = Load : &:r47_3, m46_9 +# 47| r47_5(int) = Convert : r47_4 +# 47| r47_6(int) = Mul : r47_2, r47_5 +# 47| r47_7(glval) = VariableAddress[x] : +# 47| m47_8(int) = Store : &:r47_7, r47_6 +# 48| v48_1(void) = NoOp : +# 43| v43_4(void) = ReturnVoid : +# 43| v43_5(void) = UnmodeledUse : mu* +# 43| v43_6(void) = AliasedUse : ~m43_2 +# 43| v43_7(void) = ExitFunction : + +# 50| void IntegerOps(int, int) +# 50| Block 0 +# 50| v50_1(void) = EnterFunction : +# 50| m50_2(unknown) = AliasedDefinition : +# 50| mu50_3(unknown) = UnmodeledDefinition : +# 50| r50_4(glval) = VariableAddress[x] : +# 50| m50_5(int) = InitializeParameter[x] : &:r50_4 +# 50| r50_6(glval) = VariableAddress[y] : +# 50| m50_7(int) = InitializeParameter[y] : &:r50_6 +# 51| r51_1(glval) = VariableAddress[z] : +# 51| m51_2(int) = Uninitialized[z] : &:r51_1 +# 53| r53_1(glval) = VariableAddress[x] : +# 53| r53_2(int) = Load : &:r53_1, m50_5 +# 53| r53_3(glval) = VariableAddress[y] : +# 53| r53_4(int) = Load : &:r53_3, m50_7 +# 53| r53_5(int) = Add : r53_2, r53_4 +# 53| r53_6(glval) = VariableAddress[z] : +# 53| m53_7(int) = Store : &:r53_6, r53_5 +# 54| r54_1(glval) = VariableAddress[x] : +# 54| r54_2(int) = Load : &:r54_1, m50_5 +# 54| r54_3(glval) = VariableAddress[y] : +# 54| r54_4(int) = Load : &:r54_3, m50_7 +# 54| r54_5(int) = Sub : r54_2, r54_4 +# 54| r54_6(glval) = VariableAddress[z] : +# 54| m54_7(int) = Store : &:r54_6, r54_5 +# 55| r55_1(glval) = VariableAddress[x] : +# 55| r55_2(int) = Load : &:r55_1, m50_5 +# 55| r55_3(glval) = VariableAddress[y] : +# 55| r55_4(int) = Load : &:r55_3, m50_7 +# 55| r55_5(int) = Mul : r55_2, r55_4 +# 55| r55_6(glval) = VariableAddress[z] : +# 55| m55_7(int) = Store : &:r55_6, r55_5 +# 56| r56_1(glval) = VariableAddress[x] : +# 56| r56_2(int) = Load : &:r56_1, m50_5 +# 56| r56_3(glval) = VariableAddress[y] : +# 56| r56_4(int) = Load : &:r56_3, m50_7 +# 56| r56_5(int) = Div : r56_2, r56_4 +# 56| r56_6(glval) = VariableAddress[z] : +# 56| m56_7(int) = Store : &:r56_6, r56_5 +# 57| r57_1(glval) = VariableAddress[x] : +# 57| r57_2(int) = Load : &:r57_1, m50_5 +# 57| r57_3(glval) = VariableAddress[y] : +# 57| r57_4(int) = Load : &:r57_3, m50_7 +# 57| r57_5(int) = Rem : r57_2, r57_4 +# 57| r57_6(glval) = VariableAddress[z] : +# 57| m57_7(int) = Store : &:r57_6, r57_5 +# 59| r59_1(glval) = VariableAddress[x] : +# 59| r59_2(int) = Load : &:r59_1, m50_5 +# 59| r59_3(glval) = VariableAddress[y] : +# 59| r59_4(int) = Load : &:r59_3, m50_7 +# 59| r59_5(int) = BitAnd : r59_2, r59_4 +# 59| r59_6(glval) = VariableAddress[z] : +# 59| m59_7(int) = Store : &:r59_6, r59_5 +# 60| r60_1(glval) = VariableAddress[x] : +# 60| r60_2(int) = Load : &:r60_1, m50_5 +# 60| r60_3(glval) = VariableAddress[y] : +# 60| r60_4(int) = Load : &:r60_3, m50_7 +# 60| r60_5(int) = BitOr : r60_2, r60_4 +# 60| r60_6(glval) = VariableAddress[z] : +# 60| m60_7(int) = Store : &:r60_6, r60_5 +# 61| r61_1(glval) = VariableAddress[x] : +# 61| r61_2(int) = Load : &:r61_1, m50_5 +# 61| r61_3(glval) = VariableAddress[y] : +# 61| r61_4(int) = Load : &:r61_3, m50_7 +# 61| r61_5(int) = BitXor : r61_2, r61_4 +# 61| r61_6(glval) = VariableAddress[z] : +# 61| m61_7(int) = Store : &:r61_6, r61_5 +# 63| r63_1(glval) = VariableAddress[x] : +# 63| r63_2(int) = Load : &:r63_1, m50_5 +# 63| r63_3(glval) = VariableAddress[y] : +# 63| r63_4(int) = Load : &:r63_3, m50_7 +# 63| r63_5(int) = ShiftLeft : r63_2, r63_4 +# 63| r63_6(glval) = VariableAddress[z] : +# 63| m63_7(int) = Store : &:r63_6, r63_5 +# 64| r64_1(glval) = VariableAddress[x] : +# 64| r64_2(int) = Load : &:r64_1, m50_5 +# 64| r64_3(glval) = VariableAddress[y] : +# 64| r64_4(int) = Load : &:r64_3, m50_7 +# 64| r64_5(int) = ShiftRight : r64_2, r64_4 +# 64| r64_6(glval) = VariableAddress[z] : +# 64| m64_7(int) = Store : &:r64_6, r64_5 +# 66| r66_1(glval) = VariableAddress[x] : +# 66| r66_2(int) = Load : &:r66_1, m50_5 +# 66| r66_3(glval) = VariableAddress[z] : +# 66| m66_4(int) = Store : &:r66_3, r66_2 +# 68| r68_1(glval) = VariableAddress[x] : +# 68| r68_2(int) = Load : &:r68_1, m50_5 +# 68| r68_3(glval) = VariableAddress[z] : +# 68| r68_4(int) = Load : &:r68_3, m66_4 +# 68| r68_5(int) = Add : r68_4, r68_2 +# 68| m68_6(int) = Store : &:r68_3, r68_5 +# 69| r69_1(glval) = VariableAddress[x] : +# 69| r69_2(int) = Load : &:r69_1, m50_5 +# 69| r69_3(glval) = VariableAddress[z] : +# 69| r69_4(int) = Load : &:r69_3, m68_6 +# 69| r69_5(int) = Sub : r69_4, r69_2 +# 69| m69_6(int) = Store : &:r69_3, r69_5 +# 70| r70_1(glval) = VariableAddress[x] : +# 70| r70_2(int) = Load : &:r70_1, m50_5 +# 70| r70_3(glval) = VariableAddress[z] : +# 70| r70_4(int) = Load : &:r70_3, m69_6 +# 70| r70_5(int) = Mul : r70_4, r70_2 +# 70| m70_6(int) = Store : &:r70_3, r70_5 +# 71| r71_1(glval) = VariableAddress[x] : +# 71| r71_2(int) = Load : &:r71_1, m50_5 +# 71| r71_3(glval) = VariableAddress[z] : +# 71| r71_4(int) = Load : &:r71_3, m70_6 +# 71| r71_5(int) = Div : r71_4, r71_2 +# 71| m71_6(int) = Store : &:r71_3, r71_5 +# 72| r72_1(glval) = VariableAddress[x] : +# 72| r72_2(int) = Load : &:r72_1, m50_5 +# 72| r72_3(glval) = VariableAddress[z] : +# 72| r72_4(int) = Load : &:r72_3, m71_6 +# 72| r72_5(int) = Rem : r72_4, r72_2 +# 72| m72_6(int) = Store : &:r72_3, r72_5 +# 74| r74_1(glval) = VariableAddress[x] : +# 74| r74_2(int) = Load : &:r74_1, m50_5 +# 74| r74_3(glval) = VariableAddress[z] : +# 74| r74_4(int) = Load : &:r74_3, m72_6 +# 74| r74_5(int) = BitAnd : r74_4, r74_2 +# 74| m74_6(int) = Store : &:r74_3, r74_5 +# 75| r75_1(glval) = VariableAddress[x] : +# 75| r75_2(int) = Load : &:r75_1, m50_5 +# 75| r75_3(glval) = VariableAddress[z] : +# 75| r75_4(int) = Load : &:r75_3, m74_6 +# 75| r75_5(int) = BitOr : r75_4, r75_2 +# 75| m75_6(int) = Store : &:r75_3, r75_5 +# 76| r76_1(glval) = VariableAddress[x] : +# 76| r76_2(int) = Load : &:r76_1, m50_5 +# 76| r76_3(glval) = VariableAddress[z] : +# 76| r76_4(int) = Load : &:r76_3, m75_6 +# 76| r76_5(int) = BitXor : r76_4, r76_2 +# 76| m76_6(int) = Store : &:r76_3, r76_5 +# 78| r78_1(glval) = VariableAddress[x] : +# 78| r78_2(int) = Load : &:r78_1, m50_5 +# 78| r78_3(glval) = VariableAddress[z] : +# 78| r78_4(int) = Load : &:r78_3, m76_6 +# 78| r78_5(int) = ShiftLeft : r78_4, r78_2 +# 78| m78_6(int) = Store : &:r78_3, r78_5 +# 79| r79_1(glval) = VariableAddress[x] : +# 79| r79_2(int) = Load : &:r79_1, m50_5 +# 79| r79_3(glval) = VariableAddress[z] : +# 79| r79_4(int) = Load : &:r79_3, m78_6 +# 79| r79_5(int) = ShiftRight : r79_4, r79_2 +# 79| m79_6(int) = Store : &:r79_3, r79_5 +# 81| r81_1(glval) = VariableAddress[x] : +# 81| r81_2(int) = Load : &:r81_1, m50_5 +# 81| r81_3(int) = CopyValue : r81_2 +# 81| r81_4(glval) = VariableAddress[z] : +# 81| m81_5(int) = Store : &:r81_4, r81_3 +# 82| r82_1(glval) = VariableAddress[x] : +# 82| r82_2(int) = Load : &:r82_1, m50_5 +# 82| r82_3(int) = Negate : r82_2 +# 82| r82_4(glval) = VariableAddress[z] : +# 82| m82_5(int) = Store : &:r82_4, r82_3 +# 83| r83_1(glval) = VariableAddress[x] : +# 83| r83_2(int) = Load : &:r83_1, m50_5 +# 83| r83_3(int) = BitComplement : r83_2 +# 83| r83_4(glval) = VariableAddress[z] : +# 83| m83_5(int) = Store : &:r83_4, r83_3 +# 84| r84_1(glval) = VariableAddress[x] : +# 84| r84_2(int) = Load : &:r84_1, m50_5 +# 84| r84_3(int) = Constant[0] : +# 84| r84_4(bool) = CompareNE : r84_2, r84_3 +# 84| r84_5(bool) = LogicalNot : r84_4 +# 84| r84_6(int) = Convert : r84_5 +# 84| r84_7(glval) = VariableAddress[z] : +# 84| m84_8(int) = Store : &:r84_7, r84_6 +# 85| v85_1(void) = NoOp : +# 50| v50_8(void) = ReturnVoid : +# 50| v50_9(void) = UnmodeledUse : mu* +# 50| v50_10(void) = AliasedUse : ~m50_2 +# 50| v50_11(void) = ExitFunction : + +# 87| void IntegerCompare(int, int) +# 87| Block 0 +# 87| v87_1(void) = EnterFunction : +# 87| m87_2(unknown) = AliasedDefinition : +# 87| mu87_3(unknown) = UnmodeledDefinition : +# 87| r87_4(glval) = VariableAddress[x] : +# 87| m87_5(int) = InitializeParameter[x] : &:r87_4 +# 87| r87_6(glval) = VariableAddress[y] : +# 87| m87_7(int) = InitializeParameter[y] : &:r87_6 +# 88| r88_1(glval) = VariableAddress[b] : +# 88| m88_2(bool) = Uninitialized[b] : &:r88_1 +# 90| r90_1(glval) = VariableAddress[x] : +# 90| r90_2(int) = Load : &:r90_1, m87_5 +# 90| r90_3(glval) = VariableAddress[y] : +# 90| r90_4(int) = Load : &:r90_3, m87_7 +# 90| r90_5(bool) = CompareEQ : r90_2, r90_4 +# 90| r90_6(glval) = VariableAddress[b] : +# 90| m90_7(bool) = Store : &:r90_6, r90_5 +# 91| r91_1(glval) = VariableAddress[x] : +# 91| r91_2(int) = Load : &:r91_1, m87_5 +# 91| r91_3(glval) = VariableAddress[y] : +# 91| r91_4(int) = Load : &:r91_3, m87_7 +# 91| r91_5(bool) = CompareNE : r91_2, r91_4 +# 91| r91_6(glval) = VariableAddress[b] : +# 91| m91_7(bool) = Store : &:r91_6, r91_5 +# 92| r92_1(glval) = VariableAddress[x] : +# 92| r92_2(int) = Load : &:r92_1, m87_5 +# 92| r92_3(glval) = VariableAddress[y] : +# 92| r92_4(int) = Load : &:r92_3, m87_7 +# 92| r92_5(bool) = CompareLT : r92_2, r92_4 +# 92| r92_6(glval) = VariableAddress[b] : +# 92| m92_7(bool) = Store : &:r92_6, r92_5 +# 93| r93_1(glval) = VariableAddress[x] : +# 93| r93_2(int) = Load : &:r93_1, m87_5 +# 93| r93_3(glval) = VariableAddress[y] : +# 93| r93_4(int) = Load : &:r93_3, m87_7 +# 93| r93_5(bool) = CompareGT : r93_2, r93_4 +# 93| r93_6(glval) = VariableAddress[b] : +# 93| m93_7(bool) = Store : &:r93_6, r93_5 +# 94| r94_1(glval) = VariableAddress[x] : +# 94| r94_2(int) = Load : &:r94_1, m87_5 +# 94| r94_3(glval) = VariableAddress[y] : +# 94| r94_4(int) = Load : &:r94_3, m87_7 +# 94| r94_5(bool) = CompareLE : r94_2, r94_4 +# 94| r94_6(glval) = VariableAddress[b] : +# 94| m94_7(bool) = Store : &:r94_6, r94_5 +# 95| r95_1(glval) = VariableAddress[x] : +# 95| r95_2(int) = Load : &:r95_1, m87_5 +# 95| r95_3(glval) = VariableAddress[y] : +# 95| r95_4(int) = Load : &:r95_3, m87_7 +# 95| r95_5(bool) = CompareGE : r95_2, r95_4 +# 95| r95_6(glval) = VariableAddress[b] : +# 95| m95_7(bool) = Store : &:r95_6, r95_5 +# 96| v96_1(void) = NoOp : +# 87| v87_8(void) = ReturnVoid : +# 87| v87_9(void) = UnmodeledUse : mu* +# 87| v87_10(void) = AliasedUse : ~m87_2 +# 87| v87_11(void) = ExitFunction : + +# 98| void IntegerCrement(int) +# 98| Block 0 +# 98| v98_1(void) = EnterFunction : +# 98| m98_2(unknown) = AliasedDefinition : +# 98| mu98_3(unknown) = UnmodeledDefinition : +# 98| r98_4(glval) = VariableAddress[x] : +# 98| m98_5(int) = InitializeParameter[x] : &:r98_4 +# 99| r99_1(glval) = VariableAddress[y] : +# 99| m99_2(int) = Uninitialized[y] : &:r99_1 +# 101| r101_1(glval) = VariableAddress[x] : +# 101| r101_2(int) = Load : &:r101_1, m98_5 +# 101| r101_3(int) = Constant[1] : +# 101| r101_4(int) = Add : r101_2, r101_3 +# 101| m101_5(int) = Store : &:r101_1, r101_4 +# 101| r101_6(glval) = VariableAddress[y] : +# 101| m101_7(int) = Store : &:r101_6, r101_4 +# 102| r102_1(glval) = VariableAddress[x] : +# 102| r102_2(int) = Load : &:r102_1, m101_5 +# 102| r102_3(int) = Constant[1] : +# 102| r102_4(int) = Sub : r102_2, r102_3 +# 102| m102_5(int) = Store : &:r102_1, r102_4 +# 102| r102_6(glval) = VariableAddress[y] : +# 102| m102_7(int) = Store : &:r102_6, r102_4 +# 103| r103_1(glval) = VariableAddress[x] : +# 103| r103_2(int) = Load : &:r103_1, m102_5 +# 103| r103_3(int) = Constant[1] : +# 103| r103_4(int) = Add : r103_2, r103_3 +# 103| m103_5(int) = Store : &:r103_1, r103_4 +# 103| r103_6(glval) = VariableAddress[y] : +# 103| m103_7(int) = Store : &:r103_6, r103_2 +# 104| r104_1(glval) = VariableAddress[x] : +# 104| r104_2(int) = Load : &:r104_1, m103_5 +# 104| r104_3(int) = Constant[1] : +# 104| r104_4(int) = Sub : r104_2, r104_3 +# 104| m104_5(int) = Store : &:r104_1, r104_4 +# 104| r104_6(glval) = VariableAddress[y] : +# 104| m104_7(int) = Store : &:r104_6, r104_2 +# 105| v105_1(void) = NoOp : +# 98| v98_6(void) = ReturnVoid : +# 98| v98_7(void) = UnmodeledUse : mu* +# 98| v98_8(void) = AliasedUse : ~m98_2 +# 98| v98_9(void) = ExitFunction : + +# 107| void IntegerCrement_LValue(int) +# 107| Block 0 +# 107| v107_1(void) = EnterFunction : +# 107| m107_2(unknown) = AliasedDefinition : +# 107| mu107_3(unknown) = UnmodeledDefinition : +# 107| r107_4(glval) = VariableAddress[x] : +# 107| m107_5(int) = InitializeParameter[x] : &:r107_4 +# 108| r108_1(glval) = VariableAddress[p] : +# 108| m108_2(int *) = Uninitialized[p] : &:r108_1 +# 110| r110_1(glval) = VariableAddress[x] : +# 110| r110_2(int) = Load : &:r110_1, m107_5 +# 110| r110_3(int) = Constant[1] : +# 110| r110_4(int) = Add : r110_2, r110_3 +# 110| m110_5(int) = Store : &:r110_1, r110_4 +# 110| r110_6(glval) = CopyValue : r110_1 +# 110| r110_7(int *) = CopyValue : r110_6 +# 110| r110_8(glval) = VariableAddress[p] : +# 110| m110_9(int *) = Store : &:r110_8, r110_7 +# 111| r111_1(glval) = VariableAddress[x] : +# 111| r111_2(int) = Load : &:r111_1, m110_5 +# 111| r111_3(int) = Constant[1] : +# 111| r111_4(int) = Sub : r111_2, r111_3 +# 111| m111_5(int) = Store : &:r111_1, r111_4 +# 111| r111_6(glval) = CopyValue : r111_1 +# 111| r111_7(int *) = CopyValue : r111_6 +# 111| r111_8(glval) = VariableAddress[p] : +# 111| m111_9(int *) = Store : &:r111_8, r111_7 +# 112| v112_1(void) = NoOp : +# 107| v107_6(void) = ReturnVoid : +# 107| v107_7(void) = UnmodeledUse : mu* +# 107| v107_8(void) = AliasedUse : ~m107_2 +# 107| v107_9(void) = ExitFunction : + +# 114| void FloatOps(double, double) +# 114| Block 0 +# 114| v114_1(void) = EnterFunction : +# 114| m114_2(unknown) = AliasedDefinition : +# 114| mu114_3(unknown) = UnmodeledDefinition : +# 114| r114_4(glval) = VariableAddress[x] : +# 114| m114_5(double) = InitializeParameter[x] : &:r114_4 +# 114| r114_6(glval) = VariableAddress[y] : +# 114| m114_7(double) = InitializeParameter[y] : &:r114_6 +# 115| r115_1(glval) = VariableAddress[z] : +# 115| m115_2(double) = Uninitialized[z] : &:r115_1 +# 117| r117_1(glval) = VariableAddress[x] : +# 117| r117_2(double) = Load : &:r117_1, m114_5 +# 117| r117_3(glval) = VariableAddress[y] : +# 117| r117_4(double) = Load : &:r117_3, m114_7 +# 117| r117_5(double) = Add : r117_2, r117_4 +# 117| r117_6(glval) = VariableAddress[z] : +# 117| m117_7(double) = Store : &:r117_6, r117_5 +# 118| r118_1(glval) = VariableAddress[x] : +# 118| r118_2(double) = Load : &:r118_1, m114_5 +# 118| r118_3(glval) = VariableAddress[y] : +# 118| r118_4(double) = Load : &:r118_3, m114_7 +# 118| r118_5(double) = Sub : r118_2, r118_4 +# 118| r118_6(glval) = VariableAddress[z] : +# 118| m118_7(double) = Store : &:r118_6, r118_5 +# 119| r119_1(glval) = VariableAddress[x] : +# 119| r119_2(double) = Load : &:r119_1, m114_5 +# 119| r119_3(glval) = VariableAddress[y] : +# 119| r119_4(double) = Load : &:r119_3, m114_7 +# 119| r119_5(double) = Mul : r119_2, r119_4 +# 119| r119_6(glval) = VariableAddress[z] : +# 119| m119_7(double) = Store : &:r119_6, r119_5 +# 120| r120_1(glval) = VariableAddress[x] : +# 120| r120_2(double) = Load : &:r120_1, m114_5 +# 120| r120_3(glval) = VariableAddress[y] : +# 120| r120_4(double) = Load : &:r120_3, m114_7 +# 120| r120_5(double) = Div : r120_2, r120_4 +# 120| r120_6(glval) = VariableAddress[z] : +# 120| m120_7(double) = Store : &:r120_6, r120_5 +# 122| r122_1(glval) = VariableAddress[x] : +# 122| r122_2(double) = Load : &:r122_1, m114_5 +# 122| r122_3(glval) = VariableAddress[z] : +# 122| m122_4(double) = Store : &:r122_3, r122_2 +# 124| r124_1(glval) = VariableAddress[x] : +# 124| r124_2(double) = Load : &:r124_1, m114_5 +# 124| r124_3(glval) = VariableAddress[z] : +# 124| r124_4(double) = Load : &:r124_3, m122_4 +# 124| r124_5(double) = Add : r124_4, r124_2 +# 124| m124_6(double) = Store : &:r124_3, r124_5 +# 125| r125_1(glval) = VariableAddress[x] : +# 125| r125_2(double) = Load : &:r125_1, m114_5 +# 125| r125_3(glval) = VariableAddress[z] : +# 125| r125_4(double) = Load : &:r125_3, m124_6 +# 125| r125_5(double) = Sub : r125_4, r125_2 +# 125| m125_6(double) = Store : &:r125_3, r125_5 +# 126| r126_1(glval) = VariableAddress[x] : +# 126| r126_2(double) = Load : &:r126_1, m114_5 +# 126| r126_3(glval) = VariableAddress[z] : +# 126| r126_4(double) = Load : &:r126_3, m125_6 +# 126| r126_5(double) = Mul : r126_4, r126_2 +# 126| m126_6(double) = Store : &:r126_3, r126_5 +# 127| r127_1(glval) = VariableAddress[x] : +# 127| r127_2(double) = Load : &:r127_1, m114_5 +# 127| r127_3(glval) = VariableAddress[z] : +# 127| r127_4(double) = Load : &:r127_3, m126_6 +# 127| r127_5(double) = Div : r127_4, r127_2 +# 127| m127_6(double) = Store : &:r127_3, r127_5 +# 129| r129_1(glval) = VariableAddress[x] : +# 129| r129_2(double) = Load : &:r129_1, m114_5 +# 129| r129_3(double) = CopyValue : r129_2 +# 129| r129_4(glval) = VariableAddress[z] : +# 129| m129_5(double) = Store : &:r129_4, r129_3 +# 130| r130_1(glval) = VariableAddress[x] : +# 130| r130_2(double) = Load : &:r130_1, m114_5 +# 130| r130_3(double) = Negate : r130_2 +# 130| r130_4(glval) = VariableAddress[z] : +# 130| m130_5(double) = Store : &:r130_4, r130_3 +# 131| v131_1(void) = NoOp : +# 114| v114_8(void) = ReturnVoid : +# 114| v114_9(void) = UnmodeledUse : mu* +# 114| v114_10(void) = AliasedUse : ~m114_2 +# 114| v114_11(void) = ExitFunction : + +# 133| void FloatCompare(double, double) +# 133| Block 0 +# 133| v133_1(void) = EnterFunction : +# 133| m133_2(unknown) = AliasedDefinition : +# 133| mu133_3(unknown) = UnmodeledDefinition : +# 133| r133_4(glval) = VariableAddress[x] : +# 133| m133_5(double) = InitializeParameter[x] : &:r133_4 +# 133| r133_6(glval) = VariableAddress[y] : +# 133| m133_7(double) = InitializeParameter[y] : &:r133_6 +# 134| r134_1(glval) = VariableAddress[b] : +# 134| m134_2(bool) = Uninitialized[b] : &:r134_1 +# 136| r136_1(glval) = VariableAddress[x] : +# 136| r136_2(double) = Load : &:r136_1, m133_5 +# 136| r136_3(glval) = VariableAddress[y] : +# 136| r136_4(double) = Load : &:r136_3, m133_7 +# 136| r136_5(bool) = CompareEQ : r136_2, r136_4 +# 136| r136_6(glval) = VariableAddress[b] : +# 136| m136_7(bool) = Store : &:r136_6, r136_5 +# 137| r137_1(glval) = VariableAddress[x] : +# 137| r137_2(double) = Load : &:r137_1, m133_5 +# 137| r137_3(glval) = VariableAddress[y] : +# 137| r137_4(double) = Load : &:r137_3, m133_7 +# 137| r137_5(bool) = CompareNE : r137_2, r137_4 +# 137| r137_6(glval) = VariableAddress[b] : +# 137| m137_7(bool) = Store : &:r137_6, r137_5 +# 138| r138_1(glval) = VariableAddress[x] : +# 138| r138_2(double) = Load : &:r138_1, m133_5 +# 138| r138_3(glval) = VariableAddress[y] : +# 138| r138_4(double) = Load : &:r138_3, m133_7 +# 138| r138_5(bool) = CompareLT : r138_2, r138_4 +# 138| r138_6(glval) = VariableAddress[b] : +# 138| m138_7(bool) = Store : &:r138_6, r138_5 +# 139| r139_1(glval) = VariableAddress[x] : +# 139| r139_2(double) = Load : &:r139_1, m133_5 +# 139| r139_3(glval) = VariableAddress[y] : +# 139| r139_4(double) = Load : &:r139_3, m133_7 +# 139| r139_5(bool) = CompareGT : r139_2, r139_4 +# 139| r139_6(glval) = VariableAddress[b] : +# 139| m139_7(bool) = Store : &:r139_6, r139_5 +# 140| r140_1(glval) = VariableAddress[x] : +# 140| r140_2(double) = Load : &:r140_1, m133_5 +# 140| r140_3(glval) = VariableAddress[y] : +# 140| r140_4(double) = Load : &:r140_3, m133_7 +# 140| r140_5(bool) = CompareLE : r140_2, r140_4 +# 140| r140_6(glval) = VariableAddress[b] : +# 140| m140_7(bool) = Store : &:r140_6, r140_5 +# 141| r141_1(glval) = VariableAddress[x] : +# 141| r141_2(double) = Load : &:r141_1, m133_5 +# 141| r141_3(glval) = VariableAddress[y] : +# 141| r141_4(double) = Load : &:r141_3, m133_7 +# 141| r141_5(bool) = CompareGE : r141_2, r141_4 +# 141| r141_6(glval) = VariableAddress[b] : +# 141| m141_7(bool) = Store : &:r141_6, r141_5 +# 142| v142_1(void) = NoOp : +# 133| v133_8(void) = ReturnVoid : +# 133| v133_9(void) = UnmodeledUse : mu* +# 133| v133_10(void) = AliasedUse : ~m133_2 +# 133| v133_11(void) = ExitFunction : + +# 144| void FloatCrement(float) +# 144| Block 0 +# 144| v144_1(void) = EnterFunction : +# 144| m144_2(unknown) = AliasedDefinition : +# 144| mu144_3(unknown) = UnmodeledDefinition : +# 144| r144_4(glval) = VariableAddress[x] : +# 144| m144_5(float) = InitializeParameter[x] : &:r144_4 +# 145| r145_1(glval) = VariableAddress[y] : +# 145| m145_2(float) = Uninitialized[y] : &:r145_1 +# 147| r147_1(glval) = VariableAddress[x] : +# 147| r147_2(float) = Load : &:r147_1, m144_5 +# 147| r147_3(float) = Constant[1.0] : +# 147| r147_4(float) = Add : r147_2, r147_3 +# 147| m147_5(float) = Store : &:r147_1, r147_4 +# 147| r147_6(glval) = VariableAddress[y] : +# 147| m147_7(float) = Store : &:r147_6, r147_4 +# 148| r148_1(glval) = VariableAddress[x] : +# 148| r148_2(float) = Load : &:r148_1, m147_5 +# 148| r148_3(float) = Constant[1.0] : +# 148| r148_4(float) = Sub : r148_2, r148_3 +# 148| m148_5(float) = Store : &:r148_1, r148_4 +# 148| r148_6(glval) = VariableAddress[y] : +# 148| m148_7(float) = Store : &:r148_6, r148_4 +# 149| r149_1(glval) = VariableAddress[x] : +# 149| r149_2(float) = Load : &:r149_1, m148_5 +# 149| r149_3(float) = Constant[1.0] : +# 149| r149_4(float) = Add : r149_2, r149_3 +# 149| m149_5(float) = Store : &:r149_1, r149_4 +# 149| r149_6(glval) = VariableAddress[y] : +# 149| m149_7(float) = Store : &:r149_6, r149_2 +# 150| r150_1(glval) = VariableAddress[x] : +# 150| r150_2(float) = Load : &:r150_1, m149_5 +# 150| r150_3(float) = Constant[1.0] : +# 150| r150_4(float) = Sub : r150_2, r150_3 +# 150| m150_5(float) = Store : &:r150_1, r150_4 +# 150| r150_6(glval) = VariableAddress[y] : +# 150| m150_7(float) = Store : &:r150_6, r150_2 +# 151| v151_1(void) = NoOp : +# 144| v144_6(void) = ReturnVoid : +# 144| v144_7(void) = UnmodeledUse : mu* +# 144| v144_8(void) = AliasedUse : ~m144_2 +# 144| v144_9(void) = ExitFunction : + +# 153| void PointerOps(int*, int) +# 153| Block 0 +# 153| v153_1(void) = EnterFunction : +# 153| m153_2(unknown) = AliasedDefinition : +# 153| mu153_3(unknown) = UnmodeledDefinition : +# 153| r153_4(glval) = VariableAddress[p] : +# 153| m153_5(int *) = InitializeParameter[p] : &:r153_4 +# 153| r153_6(int *) = Load : &:r153_4, m153_5 +# 153| m153_7(unknown) = InitializeIndirection[p] : &:r153_6 +# 153| m153_8(unknown) = Chi : total:m153_2, partial:m153_7 +# 153| r153_9(glval) = VariableAddress[i] : +# 153| m153_10(int) = InitializeParameter[i] : &:r153_9 +# 154| r154_1(glval) = VariableAddress[q] : +# 154| m154_2(int *) = Uninitialized[q] : &:r154_1 +# 155| r155_1(glval) = VariableAddress[b] : +# 155| m155_2(bool) = Uninitialized[b] : &:r155_1 +# 157| r157_1(glval) = VariableAddress[p] : +# 157| r157_2(int *) = Load : &:r157_1, m153_5 +# 157| r157_3(glval) = VariableAddress[i] : +# 157| r157_4(int) = Load : &:r157_3, m153_10 +# 157| r157_5(int *) = PointerAdd[4] : r157_2, r157_4 +# 157| r157_6(glval) = VariableAddress[q] : +# 157| m157_7(int *) = Store : &:r157_6, r157_5 +# 158| r158_1(glval) = VariableAddress[i] : +# 158| r158_2(int) = Load : &:r158_1, m153_10 +# 158| r158_3(glval) = VariableAddress[p] : +# 158| r158_4(int *) = Load : &:r158_3, m153_5 +# 158| r158_5(int *) = PointerAdd[4] : r158_4, r158_2 +# 158| r158_6(glval) = VariableAddress[q] : +# 158| m158_7(int *) = Store : &:r158_6, r158_5 +# 159| r159_1(glval) = VariableAddress[p] : +# 159| r159_2(int *) = Load : &:r159_1, m153_5 +# 159| r159_3(glval) = VariableAddress[i] : +# 159| r159_4(int) = Load : &:r159_3, m153_10 +# 159| r159_5(int *) = PointerSub[4] : r159_2, r159_4 +# 159| r159_6(glval) = VariableAddress[q] : +# 159| m159_7(int *) = Store : &:r159_6, r159_5 +# 160| r160_1(glval) = VariableAddress[p] : +# 160| r160_2(int *) = Load : &:r160_1, m153_5 +# 160| r160_3(glval) = VariableAddress[q] : +# 160| r160_4(int *) = Load : &:r160_3, m159_7 +# 160| r160_5(long) = PointerDiff[4] : r160_2, r160_4 +# 160| r160_6(int) = Convert : r160_5 +# 160| r160_7(glval) = VariableAddress[i] : +# 160| m160_8(int) = Store : &:r160_7, r160_6 +# 162| r162_1(glval) = VariableAddress[p] : +# 162| r162_2(int *) = Load : &:r162_1, m153_5 +# 162| r162_3(glval) = VariableAddress[q] : +# 162| m162_4(int *) = Store : &:r162_3, r162_2 +# 164| r164_1(glval) = VariableAddress[i] : +# 164| r164_2(int) = Load : &:r164_1, m160_8 +# 164| r164_3(glval) = VariableAddress[q] : +# 164| r164_4(int *) = Load : &:r164_3, m162_4 +# 164| r164_5(int *) = PointerAdd[4] : r164_4, r164_2 +# 164| m164_6(int *) = Store : &:r164_3, r164_5 +# 165| r165_1(glval) = VariableAddress[i] : +# 165| r165_2(int) = Load : &:r165_1, m160_8 +# 165| r165_3(glval) = VariableAddress[q] : +# 165| r165_4(int *) = Load : &:r165_3, m164_6 +# 165| r165_5(int *) = PointerSub[4] : r165_4, r165_2 +# 165| m165_6(int *) = Store : &:r165_3, r165_5 +# 167| r167_1(glval) = VariableAddress[p] : +# 167| r167_2(int *) = Load : &:r167_1, m153_5 +# 167| r167_3(int *) = Constant[0] : +# 167| r167_4(bool) = CompareNE : r167_2, r167_3 +# 167| r167_5(glval) = VariableAddress[b] : +# 167| m167_6(bool) = Store : &:r167_5, r167_4 +# 168| r168_1(glval) = VariableAddress[p] : +# 168| r168_2(int *) = Load : &:r168_1, m153_5 +# 168| r168_3(int *) = Constant[0] : +# 168| r168_4(bool) = CompareNE : r168_2, r168_3 +# 168| r168_5(bool) = LogicalNot : r168_4 +# 168| r168_6(glval) = VariableAddress[b] : +# 168| m168_7(bool) = Store : &:r168_6, r168_5 +# 169| v169_1(void) = NoOp : +# 153| v153_11(void) = ReturnIndirection : &:r153_6, ~m153_8 +# 153| v153_12(void) = ReturnVoid : +# 153| v153_13(void) = UnmodeledUse : mu* +# 153| v153_14(void) = AliasedUse : ~m153_8 +# 153| v153_15(void) = ExitFunction : + +# 171| void ArrayAccess(int*, int) +# 171| Block 0 +# 171| v171_1(void) = EnterFunction : +# 171| m171_2(unknown) = AliasedDefinition : +# 171| mu171_3(unknown) = UnmodeledDefinition : +# 171| r171_4(glval) = VariableAddress[p] : +# 171| m171_5(int *) = InitializeParameter[p] : &:r171_4 +# 171| r171_6(int *) = Load : &:r171_4, m171_5 +# 171| m171_7(unknown) = InitializeIndirection[p] : &:r171_6 +# 171| m171_8(unknown) = Chi : total:m171_2, partial:m171_7 +# 171| r171_9(glval) = VariableAddress[i] : +# 171| m171_10(int) = InitializeParameter[i] : &:r171_9 +# 172| r172_1(glval) = VariableAddress[x] : +# 172| m172_2(int) = Uninitialized[x] : &:r172_1 +# 174| r174_1(glval) = VariableAddress[p] : +# 174| r174_2(int *) = Load : &:r174_1, m171_5 +# 174| r174_3(glval) = VariableAddress[i] : +# 174| r174_4(int) = Load : &:r174_3, m171_10 +# 174| r174_5(glval) = PointerAdd[4] : r174_2, r174_4 +# 174| r174_6(int) = Load : &:r174_5, ~m171_8 +# 174| r174_7(glval) = VariableAddress[x] : +# 174| m174_8(int) = Store : &:r174_7, r174_6 +# 175| r175_1(glval) = VariableAddress[p] : +# 175| r175_2(int *) = Load : &:r175_1, m171_5 +# 175| r175_3(glval) = VariableAddress[i] : +# 175| r175_4(int) = Load : &:r175_3, m171_10 +# 175| r175_5(glval) = PointerAdd[4] : r175_2, r175_4 +# 175| r175_6(int) = Load : &:r175_5, ~m171_8 +# 175| r175_7(glval) = VariableAddress[x] : +# 175| m175_8(int) = Store : &:r175_7, r175_6 +# 177| r177_1(glval) = VariableAddress[x] : +# 177| r177_2(int) = Load : &:r177_1, m175_8 +# 177| r177_3(glval) = VariableAddress[p] : +# 177| r177_4(int *) = Load : &:r177_3, m171_5 +# 177| r177_5(glval) = VariableAddress[i] : +# 177| r177_6(int) = Load : &:r177_5, m171_10 +# 177| r177_7(glval) = PointerAdd[4] : r177_4, r177_6 +# 177| m177_8(int) = Store : &:r177_7, r177_2 +# 177| m177_9(unknown) = Chi : total:m171_8, partial:m177_8 +# 178| r178_1(glval) = VariableAddress[x] : +# 178| r178_2(int) = Load : &:r178_1, m175_8 +# 178| r178_3(glval) = VariableAddress[p] : +# 178| r178_4(int *) = Load : &:r178_3, m171_5 +# 178| r178_5(glval) = VariableAddress[i] : +# 178| r178_6(int) = Load : &:r178_5, m171_10 +# 178| r178_7(glval) = PointerAdd[4] : r178_4, r178_6 +# 178| m178_8(int) = Store : &:r178_7, r178_2 +# 178| m178_9(unknown) = Chi : total:m177_9, partial:m178_8 +# 180| r180_1(glval) = VariableAddress[a] : +# 180| m180_2(int[10]) = Uninitialized[a] : &:r180_1 +# 181| r181_1(glval) = VariableAddress[a] : +# 181| r181_2(int *) = Convert : r181_1 +# 181| r181_3(glval) = VariableAddress[i] : +# 181| r181_4(int) = Load : &:r181_3, m171_10 +# 181| r181_5(glval) = PointerAdd[4] : r181_2, r181_4 +# 181| r181_6(int) = Load : &:r181_5, ~m180_2 +# 181| r181_7(glval) = VariableAddress[x] : +# 181| m181_8(int) = Store : &:r181_7, r181_6 +# 182| r182_1(glval) = VariableAddress[a] : +# 182| r182_2(int *) = Convert : r182_1 +# 182| r182_3(glval) = VariableAddress[i] : +# 182| r182_4(int) = Load : &:r182_3, m171_10 +# 182| r182_5(glval) = PointerAdd[4] : r182_2, r182_4 +# 182| r182_6(int) = Load : &:r182_5, ~m180_2 +# 182| r182_7(glval) = VariableAddress[x] : +# 182| m182_8(int) = Store : &:r182_7, r182_6 +# 183| r183_1(glval) = VariableAddress[x] : +# 183| r183_2(int) = Load : &:r183_1, m182_8 +# 183| r183_3(glval) = VariableAddress[a] : +# 183| r183_4(int *) = Convert : r183_3 +# 183| r183_5(glval) = VariableAddress[i] : +# 183| r183_6(int) = Load : &:r183_5, m171_10 +# 183| r183_7(glval) = PointerAdd[4] : r183_4, r183_6 +# 183| m183_8(int) = Store : &:r183_7, r183_2 +# 183| m183_9(int[10]) = Chi : total:m180_2, partial:m183_8 +# 184| r184_1(glval) = VariableAddress[x] : +# 184| r184_2(int) = Load : &:r184_1, m182_8 +# 184| r184_3(glval) = VariableAddress[a] : +# 184| r184_4(int *) = Convert : r184_3 +# 184| r184_5(glval) = VariableAddress[i] : +# 184| r184_6(int) = Load : &:r184_5, m171_10 +# 184| r184_7(glval) = PointerAdd[4] : r184_4, r184_6 +# 184| m184_8(int) = Store : &:r184_7, r184_2 +# 184| m184_9(int[10]) = Chi : total:m183_9, partial:m184_8 +# 185| v185_1(void) = NoOp : +# 171| v171_11(void) = ReturnIndirection : &:r171_6, ~m178_9 +# 171| v171_12(void) = ReturnVoid : +# 171| v171_13(void) = UnmodeledUse : mu* +# 171| v171_14(void) = AliasedUse : ~m178_9 +# 171| v171_15(void) = ExitFunction : + +# 187| void StringLiteral(int) +# 187| Block 0 +# 187| v187_1(void) = EnterFunction : +# 187| m187_2(unknown) = AliasedDefinition : +# 187| mu187_3(unknown) = UnmodeledDefinition : +# 187| r187_4(glval) = VariableAddress[i] : +# 187| m187_5(int) = InitializeParameter[i] : &:r187_4 +# 188| r188_1(glval) = VariableAddress[c] : +# 188| r188_2(glval) = StringConstant["Foo"] : +# 188| r188_3(char *) = Convert : r188_2 +# 188| r188_4(glval) = VariableAddress[i] : +# 188| r188_5(int) = Load : &:r188_4, m187_5 +# 188| r188_6(glval) = PointerAdd[1] : r188_3, r188_5 +# 188| r188_7(char) = Load : &:r188_6, ~m187_2 +# 188| m188_8(char) = Store : &:r188_1, r188_7 +# 189| r189_1(glval) = VariableAddress[pwc] : +# 189| r189_2(glval) = StringConstant[L"Bar"] : +# 189| r189_3(wchar_t *) = Convert : r189_2 +# 189| r189_4(wchar_t *) = Convert : r189_3 +# 189| m189_5(wchar_t *) = Store : &:r189_1, r189_4 +# 190| r190_1(glval) = VariableAddress[wc] : +# 190| r190_2(glval) = VariableAddress[pwc] : +# 190| r190_3(wchar_t *) = Load : &:r190_2, m189_5 +# 190| r190_4(glval) = VariableAddress[i] : +# 190| r190_5(int) = Load : &:r190_4, m187_5 +# 190| r190_6(glval) = PointerAdd[4] : r190_3, r190_5 +# 190| r190_7(wchar_t) = Load : &:r190_6, ~m187_2 +# 190| m190_8(wchar_t) = Store : &:r190_1, r190_7 +# 191| v191_1(void) = NoOp : +# 187| v187_6(void) = ReturnVoid : +# 187| v187_7(void) = UnmodeledUse : mu* +# 187| v187_8(void) = AliasedUse : ~m187_2 +# 187| v187_9(void) = ExitFunction : + +# 193| void PointerCompare(int*, int*) +# 193| Block 0 +# 193| v193_1(void) = EnterFunction : +# 193| m193_2(unknown) = AliasedDefinition : +# 193| mu193_3(unknown) = UnmodeledDefinition : +# 193| r193_4(glval) = VariableAddress[p] : +# 193| m193_5(int *) = InitializeParameter[p] : &:r193_4 +# 193| r193_6(int *) = Load : &:r193_4, m193_5 +# 193| m193_7(unknown) = InitializeIndirection[p] : &:r193_6 +# 193| m193_8(unknown) = Chi : total:m193_2, partial:m193_7 +# 193| r193_9(glval) = VariableAddress[q] : +# 193| m193_10(int *) = InitializeParameter[q] : &:r193_9 +# 193| r193_11(int *) = Load : &:r193_9, m193_10 +# 193| m193_12(unknown) = InitializeIndirection[q] : &:r193_11 +# 193| m193_13(unknown) = Chi : total:m193_8, partial:m193_12 +# 194| r194_1(glval) = VariableAddress[b] : +# 194| m194_2(bool) = Uninitialized[b] : &:r194_1 +# 196| r196_1(glval) = VariableAddress[p] : +# 196| r196_2(int *) = Load : &:r196_1, m193_5 +# 196| r196_3(glval) = VariableAddress[q] : +# 196| r196_4(int *) = Load : &:r196_3, m193_10 +# 196| r196_5(bool) = CompareEQ : r196_2, r196_4 +# 196| r196_6(glval) = VariableAddress[b] : +# 196| m196_7(bool) = Store : &:r196_6, r196_5 +# 197| r197_1(glval) = VariableAddress[p] : +# 197| r197_2(int *) = Load : &:r197_1, m193_5 +# 197| r197_3(glval) = VariableAddress[q] : +# 197| r197_4(int *) = Load : &:r197_3, m193_10 +# 197| r197_5(bool) = CompareNE : r197_2, r197_4 +# 197| r197_6(glval) = VariableAddress[b] : +# 197| m197_7(bool) = Store : &:r197_6, r197_5 +# 198| r198_1(glval) = VariableAddress[p] : +# 198| r198_2(int *) = Load : &:r198_1, m193_5 +# 198| r198_3(glval) = VariableAddress[q] : +# 198| r198_4(int *) = Load : &:r198_3, m193_10 +# 198| r198_5(bool) = CompareLT : r198_2, r198_4 +# 198| r198_6(glval) = VariableAddress[b] : +# 198| m198_7(bool) = Store : &:r198_6, r198_5 +# 199| r199_1(glval) = VariableAddress[p] : +# 199| r199_2(int *) = Load : &:r199_1, m193_5 +# 199| r199_3(glval) = VariableAddress[q] : +# 199| r199_4(int *) = Load : &:r199_3, m193_10 +# 199| r199_5(bool) = CompareGT : r199_2, r199_4 +# 199| r199_6(glval) = VariableAddress[b] : +# 199| m199_7(bool) = Store : &:r199_6, r199_5 +# 200| r200_1(glval) = VariableAddress[p] : +# 200| r200_2(int *) = Load : &:r200_1, m193_5 +# 200| r200_3(glval) = VariableAddress[q] : +# 200| r200_4(int *) = Load : &:r200_3, m193_10 +# 200| r200_5(bool) = CompareLE : r200_2, r200_4 +# 200| r200_6(glval) = VariableAddress[b] : +# 200| m200_7(bool) = Store : &:r200_6, r200_5 +# 201| r201_1(glval) = VariableAddress[p] : +# 201| r201_2(int *) = Load : &:r201_1, m193_5 +# 201| r201_3(glval) = VariableAddress[q] : +# 201| r201_4(int *) = Load : &:r201_3, m193_10 +# 201| r201_5(bool) = CompareGE : r201_2, r201_4 +# 201| r201_6(glval) = VariableAddress[b] : +# 201| m201_7(bool) = Store : &:r201_6, r201_5 +# 202| v202_1(void) = NoOp : +# 193| v193_14(void) = ReturnIndirection : &:r193_6, ~m193_13 +# 193| v193_15(void) = ReturnIndirection : &:r193_11, ~m193_13 +# 193| v193_16(void) = ReturnVoid : +# 193| v193_17(void) = UnmodeledUse : mu* +# 193| v193_18(void) = AliasedUse : ~m193_13 +# 193| v193_19(void) = ExitFunction : + +# 204| void PointerCrement(int*) +# 204| Block 0 +# 204| v204_1(void) = EnterFunction : +# 204| m204_2(unknown) = AliasedDefinition : +# 204| mu204_3(unknown) = UnmodeledDefinition : +# 204| r204_4(glval) = VariableAddress[p] : +# 204| m204_5(int *) = InitializeParameter[p] : &:r204_4 +# 204| r204_6(int *) = Load : &:r204_4, m204_5 +# 204| m204_7(unknown) = InitializeIndirection[p] : &:r204_6 +# 204| m204_8(unknown) = Chi : total:m204_2, partial:m204_7 +# 205| r205_1(glval) = VariableAddress[q] : +# 205| m205_2(int *) = Uninitialized[q] : &:r205_1 +# 207| r207_1(glval) = VariableAddress[p] : +# 207| r207_2(int *) = Load : &:r207_1, m204_5 +# 207| r207_3(int) = Constant[1] : +# 207| r207_4(int *) = PointerAdd[4] : r207_2, r207_3 +# 207| m207_5(int *) = Store : &:r207_1, r207_4 +# 207| r207_6(glval) = VariableAddress[q] : +# 207| m207_7(int *) = Store : &:r207_6, r207_4 +# 208| r208_1(glval) = VariableAddress[p] : +# 208| r208_2(int *) = Load : &:r208_1, m207_5 +# 208| r208_3(int) = Constant[1] : +# 208| r208_4(int *) = PointerSub[4] : r208_2, r208_3 +# 208| m208_5(int *) = Store : &:r208_1, r208_4 +# 208| r208_6(glval) = VariableAddress[q] : +# 208| m208_7(int *) = Store : &:r208_6, r208_4 +# 209| r209_1(glval) = VariableAddress[p] : +# 209| r209_2(int *) = Load : &:r209_1, m208_5 +# 209| r209_3(int) = Constant[1] : +# 209| r209_4(int *) = PointerAdd[4] : r209_2, r209_3 +# 209| m209_5(int *) = Store : &:r209_1, r209_4 +# 209| r209_6(glval) = VariableAddress[q] : +# 209| m209_7(int *) = Store : &:r209_6, r209_2 +# 210| r210_1(glval) = VariableAddress[p] : +# 210| r210_2(int *) = Load : &:r210_1, m209_5 +# 210| r210_3(int) = Constant[1] : +# 210| r210_4(int *) = PointerSub[4] : r210_2, r210_3 +# 210| m210_5(int *) = Store : &:r210_1, r210_4 +# 210| r210_6(glval) = VariableAddress[q] : +# 210| m210_7(int *) = Store : &:r210_6, r210_2 +# 211| v211_1(void) = NoOp : +# 204| v204_9(void) = ReturnIndirection : &:r204_6, ~m204_8 +# 204| v204_10(void) = ReturnVoid : +# 204| v204_11(void) = UnmodeledUse : mu* +# 204| v204_12(void) = AliasedUse : ~m204_8 +# 204| v204_13(void) = ExitFunction : + +# 213| void CompoundAssignment() +# 213| Block 0 +# 213| v213_1(void) = EnterFunction : +# 213| m213_2(unknown) = AliasedDefinition : +# 213| mu213_3(unknown) = UnmodeledDefinition : +# 215| r215_1(glval) = VariableAddress[x] : +# 215| r215_2(int) = Constant[5] : +# 215| m215_3(int) = Store : &:r215_1, r215_2 +# 216| r216_1(int) = Constant[7] : +# 216| r216_2(glval) = VariableAddress[x] : +# 216| r216_3(int) = Load : &:r216_2, m215_3 +# 216| r216_4(int) = Add : r216_3, r216_1 +# 216| m216_5(int) = Store : &:r216_2, r216_4 +# 219| r219_1(glval) = VariableAddress[y] : +# 219| r219_2(short) = Constant[5] : +# 219| m219_3(short) = Store : &:r219_1, r219_2 +# 220| r220_1(glval) = VariableAddress[x] : +# 220| r220_2(int) = Load : &:r220_1, m216_5 +# 220| r220_3(glval) = VariableAddress[y] : +# 220| r220_4(short) = Load : &:r220_3, m219_3 +# 220| r220_5(int) = Convert : r220_4 +# 220| r220_6(int) = Add : r220_5, r220_2 +# 220| r220_7(short) = Convert : r220_6 +# 220| m220_8(short) = Store : &:r220_3, r220_7 +# 223| r223_1(int) = Constant[1] : +# 223| r223_2(glval) = VariableAddress[y] : +# 223| r223_3(short) = Load : &:r223_2, m220_8 +# 223| r223_4(short) = ShiftLeft : r223_3, r223_1 +# 223| m223_5(short) = Store : &:r223_2, r223_4 +# 226| r226_1(glval) = VariableAddress[z] : +# 226| r226_2(long) = Constant[7] : +# 226| m226_3(long) = Store : &:r226_1, r226_2 +# 227| r227_1(float) = Constant[2.0] : +# 227| r227_2(glval) = VariableAddress[z] : +# 227| r227_3(long) = Load : &:r227_2, m226_3 +# 227| r227_4(float) = Convert : r227_3 +# 227| r227_5(float) = Add : r227_4, r227_1 +# 227| r227_6(long) = Convert : r227_5 +# 227| m227_7(long) = Store : &:r227_2, r227_6 +# 228| v228_1(void) = NoOp : +# 213| v213_4(void) = ReturnVoid : +# 213| v213_5(void) = UnmodeledUse : mu* +# 213| v213_6(void) = AliasedUse : ~m213_2 +# 213| v213_7(void) = ExitFunction : + +# 230| void UninitializedVariables() +# 230| Block 0 +# 230| v230_1(void) = EnterFunction : +# 230| m230_2(unknown) = AliasedDefinition : +# 230| mu230_3(unknown) = UnmodeledDefinition : +# 231| r231_1(glval) = VariableAddress[x] : +# 231| m231_2(int) = Uninitialized[x] : &:r231_1 +# 232| r232_1(glval) = VariableAddress[y] : +# 232| r232_2(glval) = VariableAddress[x] : +# 232| r232_3(int) = Load : &:r232_2, m231_2 +# 232| m232_4(int) = Store : &:r232_1, r232_3 +# 233| v233_1(void) = NoOp : +# 230| v230_4(void) = ReturnVoid : +# 230| v230_5(void) = UnmodeledUse : mu* +# 230| v230_6(void) = AliasedUse : ~m230_2 +# 230| v230_7(void) = ExitFunction : + +# 235| int Parameters(int, int) +# 235| Block 0 +# 235| v235_1(void) = EnterFunction : +# 235| m235_2(unknown) = AliasedDefinition : +# 235| mu235_3(unknown) = UnmodeledDefinition : +# 235| r235_4(glval) = VariableAddress[x] : +# 235| m235_5(int) = InitializeParameter[x] : &:r235_4 +# 235| r235_6(glval) = VariableAddress[y] : +# 235| m235_7(int) = InitializeParameter[y] : &:r235_6 +# 236| r236_1(glval) = VariableAddress[#return] : +# 236| r236_2(glval) = VariableAddress[x] : +# 236| r236_3(int) = Load : &:r236_2, m235_5 +# 236| r236_4(glval) = VariableAddress[y] : +# 236| r236_5(int) = Load : &:r236_4, m235_7 +# 236| r236_6(int) = Rem : r236_3, r236_5 +# 236| m236_7(int) = Store : &:r236_1, r236_6 +# 235| r235_8(glval) = VariableAddress[#return] : +# 235| v235_9(void) = ReturnValue : &:r235_8, m236_7 +# 235| v235_10(void) = UnmodeledUse : mu* +# 235| v235_11(void) = AliasedUse : ~m235_2 +# 235| v235_12(void) = ExitFunction : + +# 239| void IfStatements(bool, int, int) +# 239| Block 0 +# 239| v239_1(void) = EnterFunction : +# 239| m239_2(unknown) = AliasedDefinition : +# 239| mu239_3(unknown) = UnmodeledDefinition : +# 239| r239_4(glval) = VariableAddress[b] : +# 239| m239_5(bool) = InitializeParameter[b] : &:r239_4 +# 239| r239_6(glval) = VariableAddress[x] : +# 239| m239_7(int) = InitializeParameter[x] : &:r239_6 +# 239| r239_8(glval) = VariableAddress[y] : +# 239| m239_9(int) = InitializeParameter[y] : &:r239_8 +# 240| r240_1(glval) = VariableAddress[b] : +# 240| r240_2(bool) = Load : &:r240_1, m239_5 +# 240| v240_3(void) = ConditionalBranch : r240_2 +#-----| False -> Block 1 +#-----| True -> Block 7 + +# 243| Block 1 +# 243| r243_1(glval) = VariableAddress[b] : +# 243| r243_2(bool) = Load : &:r243_1, m239_5 +# 243| v243_3(void) = ConditionalBranch : r243_2 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 244| Block 2 +# 244| r244_1(glval) = VariableAddress[y] : +# 244| r244_2(int) = Load : &:r244_1, m239_9 +# 244| r244_3(glval) = VariableAddress[x] : +# 244| m244_4(int) = Store : &:r244_3, r244_2 +#-----| Goto -> Block 3 + +# 247| Block 3 +# 247| m247_1(int) = Phi : from 1:m239_7, from 2:m244_4 +# 247| r247_2(glval) = VariableAddress[x] : +# 247| r247_3(int) = Load : &:r247_2, m247_1 +# 247| r247_4(int) = Constant[7] : +# 247| r247_5(bool) = CompareLT : r247_3, r247_4 +# 247| v247_6(void) = ConditionalBranch : r247_5 +#-----| False -> Block 5 +#-----| True -> Block 4 + +# 248| Block 4 +# 248| r248_1(int) = Constant[2] : +# 248| r248_2(glval) = VariableAddress[x] : +# 248| m248_3(int) = Store : &:r248_2, r248_1 +#-----| Goto -> Block 6 + +# 250| Block 5 +# 250| r250_1(int) = Constant[7] : +# 250| r250_2(glval) = VariableAddress[x] : +# 250| m250_3(int) = Store : &:r250_2, r250_1 +#-----| Goto -> Block 6 + +# 251| Block 6 +# 251| v251_1(void) = NoOp : +# 239| v239_10(void) = ReturnVoid : +# 239| v239_11(void) = UnmodeledUse : mu* +# 239| v239_12(void) = AliasedUse : ~m239_2 +# 239| v239_13(void) = ExitFunction : + +# 240| Block 7 +# 240| v240_4(void) = NoOp : +#-----| Goto -> Block 1 + +# 253| void WhileStatements(int) +# 253| Block 0 +# 253| v253_1(void) = EnterFunction : +# 253| m253_2(unknown) = AliasedDefinition : +# 253| mu253_3(unknown) = UnmodeledDefinition : +# 253| r253_4(glval) = VariableAddress[n] : +# 253| m253_5(int) = InitializeParameter[n] : &:r253_4 +#-----| Goto -> Block 3 + +# 255| Block 1 +# 255| r255_1(int) = Constant[1] : +# 255| r255_2(glval) = VariableAddress[n] : +# 255| r255_3(int) = Load : &:r255_2, m254_1 +# 255| r255_4(int) = Sub : r255_3, r255_1 +# 255| m255_5(int) = Store : &:r255_2, r255_4 +#-----| Goto (back edge) -> Block 3 + +# 257| Block 2 +# 257| v257_1(void) = NoOp : +# 253| v253_6(void) = ReturnVoid : +# 253| v253_7(void) = UnmodeledUse : mu* +# 253| v253_8(void) = AliasedUse : ~m253_2 +# 253| v253_9(void) = ExitFunction : + +# 254| Block 3 +# 254| m254_1(int) = Phi : from 0:m253_5, from 1:m255_5 +# 254| r254_2(glval) = VariableAddress[n] : +# 254| r254_3(int) = Load : &:r254_2, m254_1 +# 254| r254_4(int) = Constant[0] : +# 254| r254_5(bool) = CompareGT : r254_3, r254_4 +# 254| v254_6(void) = ConditionalBranch : r254_5 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 259| void DoStatements(int) +# 259| Block 0 +# 259| v259_1(void) = EnterFunction : +# 259| m259_2(unknown) = AliasedDefinition : +# 259| mu259_3(unknown) = UnmodeledDefinition : +# 259| r259_4(glval) = VariableAddress[n] : +# 259| m259_5(int) = InitializeParameter[n] : &:r259_4 +#-----| Goto -> Block 1 + +# 261| Block 1 +# 261| m261_1(int) = Phi : from 0:m259_5, from 1:m261_6 +# 261| r261_2(int) = Constant[1] : +# 261| r261_3(glval) = VariableAddress[n] : +# 261| r261_4(int) = Load : &:r261_3, m261_1 +# 261| r261_5(int) = Sub : r261_4, r261_2 +# 261| m261_6(int) = Store : &:r261_3, r261_5 +# 262| r262_1(glval) = VariableAddress[n] : +# 262| r262_2(int) = Load : &:r262_1, m261_6 +# 262| r262_3(int) = Constant[0] : +# 262| r262_4(bool) = CompareGT : r262_2, r262_3 +# 262| v262_5(void) = ConditionalBranch : r262_4 +#-----| False -> Block 2 +#-----| True (back edge) -> Block 1 + +# 263| Block 2 +# 263| v263_1(void) = NoOp : +# 259| v259_6(void) = ReturnVoid : +# 259| v259_7(void) = UnmodeledUse : mu* +# 259| v259_8(void) = AliasedUse : ~m259_2 +# 259| v259_9(void) = ExitFunction : + +# 265| void For_Empty() +# 265| Block 0 +# 265| v265_1(void) = EnterFunction : +# 265| m265_2(unknown) = AliasedDefinition : +# 265| mu265_3(unknown) = UnmodeledDefinition : +# 266| r266_1(glval) = VariableAddress[j] : +# 266| m266_2(int) = Uninitialized[j] : &:r266_1 +#-----| Goto -> Block 1 + +# 268| Block 1 +# 268| v268_1(void) = NoOp : +#-----| Goto (back edge) -> Block 1 + +# 272| void For_Init() +# 272| Block 0 +# 272| v272_1(void) = EnterFunction : +# 272| m272_2(unknown) = AliasedDefinition : +# 272| mu272_3(unknown) = UnmodeledDefinition : +# 273| r273_1(glval) = VariableAddress[i] : +# 273| r273_2(int) = Constant[0] : +# 273| m273_3(int) = Store : &:r273_1, r273_2 +#-----| Goto -> Block 1 + +# 274| Block 1 +# 274| v274_1(void) = NoOp : +#-----| Goto (back edge) -> Block 1 + +# 278| void For_Condition() +# 278| Block 0 +# 278| v278_1(void) = EnterFunction : +# 278| m278_2(unknown) = AliasedDefinition : +# 278| mu278_3(unknown) = UnmodeledDefinition : +# 279| r279_1(glval) = VariableAddress[i] : +# 279| r279_2(int) = Constant[0] : +# 279| m279_3(int) = Store : &:r279_1, r279_2 +#-----| Goto -> Block 1 + +# 280| Block 1 +# 280| r280_1(glval) = VariableAddress[i] : +# 280| r280_2(int) = Load : &:r280_1, m279_3 +# 280| r280_3(int) = Constant[10] : +# 280| r280_4(bool) = CompareLT : r280_2, r280_3 +# 280| v280_5(void) = ConditionalBranch : r280_4 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 281| Block 2 +# 281| v281_1(void) = NoOp : +#-----| Goto (back edge) -> Block 1 + +# 278| Block 3 +# 278| v278_4(void) = Unreached : + +# 285| void For_Update() +# 285| Block 0 +# 285| v285_1(void) = EnterFunction : +# 285| m285_2(unknown) = AliasedDefinition : +# 285| mu285_3(unknown) = UnmodeledDefinition : +# 286| r286_1(glval) = VariableAddress[i] : +# 286| r286_2(int) = Constant[0] : +# 286| m286_3(int) = Store : &:r286_1, r286_2 +#-----| Goto -> Block 1 + +# 288| Block 1 +# 288| m288_1(int) = Phi : from 0:m286_3, from 1:m287_5 +# 288| v288_2(void) = NoOp : +# 287| r287_1(int) = Constant[1] : +# 287| r287_2(glval) = VariableAddress[i] : +# 287| r287_3(int) = Load : &:r287_2, m288_1 +# 287| r287_4(int) = Add : r287_3, r287_1 +# 287| m287_5(int) = Store : &:r287_2, r287_4 +#-----| Goto (back edge) -> Block 1 + +# 292| void For_InitCondition() +# 292| Block 0 +# 292| v292_1(void) = EnterFunction : +# 292| m292_2(unknown) = AliasedDefinition : +# 292| mu292_3(unknown) = UnmodeledDefinition : +# 293| r293_1(glval) = VariableAddress[i] : +# 293| r293_2(int) = Constant[0] : +# 293| m293_3(int) = Store : &:r293_1, r293_2 +#-----| Goto -> Block 1 + +# 293| Block 1 +# 293| r293_4(glval) = VariableAddress[i] : +# 293| r293_5(int) = Load : &:r293_4, m293_3 +# 293| r293_6(int) = Constant[10] : +# 293| r293_7(bool) = CompareLT : r293_5, r293_6 +# 293| v293_8(void) = ConditionalBranch : r293_7 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 294| Block 2 +# 294| v294_1(void) = NoOp : +#-----| Goto (back edge) -> Block 1 + +# 292| Block 3 +# 292| v292_4(void) = Unreached : + +# 298| void For_InitUpdate() +# 298| Block 0 +# 298| v298_1(void) = EnterFunction : +# 298| m298_2(unknown) = AliasedDefinition : +# 298| mu298_3(unknown) = UnmodeledDefinition : +# 299| r299_1(glval) = VariableAddress[i] : +# 299| r299_2(int) = Constant[0] : +# 299| m299_3(int) = Store : &:r299_1, r299_2 +#-----| Goto -> Block 1 + +# 300| Block 1 +# 300| m300_1(int) = Phi : from 0:m299_3, from 1:m299_8 +# 300| v300_2(void) = NoOp : +# 299| r299_4(int) = Constant[1] : +# 299| r299_5(glval) = VariableAddress[i] : +# 299| r299_6(int) = Load : &:r299_5, m300_1 +# 299| r299_7(int) = Add : r299_6, r299_4 +# 299| m299_8(int) = Store : &:r299_5, r299_7 +#-----| Goto (back edge) -> Block 1 + +# 304| void For_ConditionUpdate() +# 304| Block 0 +# 304| v304_1(void) = EnterFunction : +# 304| m304_2(unknown) = AliasedDefinition : +# 304| mu304_3(unknown) = UnmodeledDefinition : +# 305| r305_1(glval) = VariableAddress[i] : +# 305| r305_2(int) = Constant[0] : +# 305| m305_3(int) = Store : &:r305_1, r305_2 +#-----| Goto -> Block 1 + +# 306| Block 1 +# 306| m306_1(int) = Phi : from 0:m305_3, from 2:m306_11 +# 306| r306_2(glval) = VariableAddress[i] : +# 306| r306_3(int) = Load : &:r306_2, m306_1 +# 306| r306_4(int) = Constant[10] : +# 306| r306_5(bool) = CompareLT : r306_3, r306_4 +# 306| v306_6(void) = ConditionalBranch : r306_5 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 307| Block 2 +# 307| v307_1(void) = NoOp : +# 306| r306_7(int) = Constant[1] : +# 306| r306_8(glval) = VariableAddress[i] : +# 306| r306_9(int) = Load : &:r306_8, m306_1 +# 306| r306_10(int) = Add : r306_9, r306_7 +# 306| m306_11(int) = Store : &:r306_8, r306_10 +#-----| Goto (back edge) -> Block 1 + +# 309| Block 3 +# 309| v309_1(void) = NoOp : +# 304| v304_4(void) = ReturnVoid : +# 304| v304_5(void) = UnmodeledUse : mu* +# 304| v304_6(void) = AliasedUse : ~m304_2 +# 304| v304_7(void) = ExitFunction : + +# 311| void For_InitConditionUpdate() +# 311| Block 0 +# 311| v311_1(void) = EnterFunction : +# 311| m311_2(unknown) = AliasedDefinition : +# 311| mu311_3(unknown) = UnmodeledDefinition : +# 312| r312_1(glval) = VariableAddress[i] : +# 312| r312_2(int) = Constant[0] : +# 312| m312_3(int) = Store : &:r312_1, r312_2 +#-----| Goto -> Block 1 + +# 312| Block 1 +# 312| m312_4(int) = Phi : from 0:m312_3, from 2:m312_14 +# 312| r312_5(glval) = VariableAddress[i] : +# 312| r312_6(int) = Load : &:r312_5, m312_4 +# 312| r312_7(int) = Constant[10] : +# 312| r312_8(bool) = CompareLT : r312_6, r312_7 +# 312| v312_9(void) = ConditionalBranch : r312_8 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 313| Block 2 +# 313| v313_1(void) = NoOp : +# 312| r312_10(int) = Constant[1] : +# 312| r312_11(glval) = VariableAddress[i] : +# 312| r312_12(int) = Load : &:r312_11, m312_4 +# 312| r312_13(int) = Add : r312_12, r312_10 +# 312| m312_14(int) = Store : &:r312_11, r312_13 +#-----| Goto (back edge) -> Block 1 + +# 315| Block 3 +# 315| v315_1(void) = NoOp : +# 311| v311_4(void) = ReturnVoid : +# 311| v311_5(void) = UnmodeledUse : mu* +# 311| v311_6(void) = AliasedUse : ~m311_2 +# 311| v311_7(void) = ExitFunction : + +# 317| void For_Break() +# 317| Block 0 +# 317| v317_1(void) = EnterFunction : +# 317| m317_2(unknown) = AliasedDefinition : +# 317| mu317_3(unknown) = UnmodeledDefinition : +# 318| r318_1(glval) = VariableAddress[i] : +# 318| r318_2(int) = Constant[0] : +# 318| m318_3(int) = Store : &:r318_1, r318_2 +#-----| Goto -> Block 1 + +# 318| Block 1 +# 318| m318_4(int) = Phi : from 0:m318_3, from 2:m318_14 +# 318| r318_5(glval) = VariableAddress[i] : +# 318| r318_6(int) = Load : &:r318_5, m318_4 +# 318| r318_7(int) = Constant[10] : +# 318| r318_8(bool) = CompareLT : r318_6, r318_7 +# 318| v318_9(void) = ConditionalBranch : r318_8 +#-----| False -> Block 5 +#-----| True -> Block 3 + +# 318| Block 2 +# 318| r318_10(int) = Constant[1] : +# 318| r318_11(glval) = VariableAddress[i] : +# 318| r318_12(int) = Load : &:r318_11, m318_4 +# 318| r318_13(int) = Add : r318_12, r318_10 +# 318| m318_14(int) = Store : &:r318_11, r318_13 +#-----| Goto (back edge) -> Block 1 + +# 319| Block 3 +# 319| r319_1(glval) = VariableAddress[i] : +# 319| r319_2(int) = Load : &:r319_1, m318_4 +# 319| r319_3(int) = Constant[5] : +# 319| r319_4(bool) = CompareEQ : r319_2, r319_3 +# 319| v319_5(void) = ConditionalBranch : r319_4 +#-----| False -> Block 2 +#-----| True -> Block 4 + +# 320| Block 4 +# 320| v320_1(void) = NoOp : +#-----| Goto -> Block 5 + +# 322| Block 5 +# 322| v322_1(void) = NoOp : +# 323| v323_1(void) = NoOp : +# 317| v317_4(void) = ReturnVoid : +# 317| v317_5(void) = UnmodeledUse : mu* +# 317| v317_6(void) = AliasedUse : ~m317_2 +# 317| v317_7(void) = ExitFunction : + +# 325| void For_Continue_Update() +# 325| Block 0 +# 325| v325_1(void) = EnterFunction : +# 325| m325_2(unknown) = AliasedDefinition : +# 325| mu325_3(unknown) = UnmodeledDefinition : +# 326| r326_1(glval) = VariableAddress[i] : +# 326| r326_2(int) = Constant[0] : +# 326| m326_3(int) = Store : &:r326_1, r326_2 +#-----| Goto -> Block 1 + +# 326| Block 1 +# 326| m326_4(int) = Phi : from 0:m326_3, from 4:m326_15 +# 326| r326_5(glval) = VariableAddress[i] : +# 326| r326_6(int) = Load : &:r326_5, m326_4 +# 326| r326_7(int) = Constant[10] : +# 326| r326_8(bool) = CompareLT : r326_6, r326_7 +# 326| v326_9(void) = ConditionalBranch : r326_8 +#-----| False -> Block 5 +#-----| True -> Block 2 + +# 327| Block 2 +# 327| r327_1(glval) = VariableAddress[i] : +# 327| r327_2(int) = Load : &:r327_1, m326_4 +# 327| r327_3(int) = Constant[5] : +# 327| r327_4(bool) = CompareEQ : r327_2, r327_3 +# 327| v327_5(void) = ConditionalBranch : r327_4 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 328| Block 3 +# 328| v328_1(void) = NoOp : +#-----| Goto -> Block 4 + +# 326| Block 4 +# 326| v326_10(void) = NoOp : +# 326| r326_11(int) = Constant[1] : +# 326| r326_12(glval) = VariableAddress[i] : +# 326| r326_13(int) = Load : &:r326_12, m326_4 +# 326| r326_14(int) = Add : r326_13, r326_11 +# 326| m326_15(int) = Store : &:r326_12, r326_14 +#-----| Goto (back edge) -> Block 1 + +# 331| Block 5 +# 331| v331_1(void) = NoOp : +# 325| v325_4(void) = ReturnVoid : +# 325| v325_5(void) = UnmodeledUse : mu* +# 325| v325_6(void) = AliasedUse : ~m325_2 +# 325| v325_7(void) = ExitFunction : + +# 333| void For_Continue_NoUpdate() +# 333| Block 0 +# 333| v333_1(void) = EnterFunction : +# 333| m333_2(unknown) = AliasedDefinition : +# 333| mu333_3(unknown) = UnmodeledDefinition : +# 334| r334_1(glval) = VariableAddress[i] : +# 334| r334_2(int) = Constant[0] : +# 334| m334_3(int) = Store : &:r334_1, r334_2 +#-----| Goto -> Block 1 + +# 334| Block 1 +# 334| r334_4(glval) = VariableAddress[i] : +# 334| r334_5(int) = Load : &:r334_4, m334_3 +# 334| r334_6(int) = Constant[10] : +# 334| r334_7(bool) = CompareLT : r334_5, r334_6 +# 334| v334_8(void) = ConditionalBranch : r334_7 +#-----| False -> Block 4 +#-----| True -> Block 2 + +# 335| Block 2 +# 335| r335_1(glval) = VariableAddress[i] : +# 335| r335_2(int) = Load : &:r335_1, m334_3 +# 335| r335_3(int) = Constant[5] : +# 335| r335_4(bool) = CompareEQ : r335_2, r335_3 +# 335| v335_5(void) = ConditionalBranch : r335_4 +#-----| False -> Block 3 +#-----| True -> Block 4 + +# 334| Block 3 +# 334| v334_9(void) = NoOp : +#-----| Goto (back edge) -> Block 1 + +# 333| Block 4 +# 333| v333_4(void) = Unreached : + +# 341| int Dereference(int*) +# 341| Block 0 +# 341| v341_1(void) = EnterFunction : +# 341| m341_2(unknown) = AliasedDefinition : +# 341| mu341_3(unknown) = UnmodeledDefinition : +# 341| r341_4(glval) = VariableAddress[p] : +# 341| m341_5(int *) = InitializeParameter[p] : &:r341_4 +# 341| r341_6(int *) = Load : &:r341_4, m341_5 +# 341| m341_7(unknown) = InitializeIndirection[p] : &:r341_6 +# 341| m341_8(unknown) = Chi : total:m341_2, partial:m341_7 +# 342| r342_1(int) = Constant[1] : +# 342| r342_2(glval) = VariableAddress[p] : +# 342| r342_3(int *) = Load : &:r342_2, m341_5 +# 342| r342_4(glval) = CopyValue : r342_3 +# 342| m342_5(int) = Store : &:r342_4, r342_1 +# 342| m342_6(unknown) = Chi : total:m341_8, partial:m342_5 +# 343| r343_1(glval) = VariableAddress[#return] : +# 343| r343_2(glval) = VariableAddress[p] : +# 343| r343_3(int *) = Load : &:r343_2, m341_5 +# 343| r343_4(int) = Load : &:r343_3, ~m342_6 +# 343| m343_5(int) = Store : &:r343_1, r343_4 +# 341| v341_9(void) = ReturnIndirection : &:r341_6, ~m342_6 +# 341| r341_10(glval) = VariableAddress[#return] : +# 341| v341_11(void) = ReturnValue : &:r341_10, m343_5 +# 341| v341_12(void) = UnmodeledUse : mu* +# 341| v341_13(void) = AliasedUse : ~m342_6 +# 341| v341_14(void) = ExitFunction : + +# 348| int* AddressOf() +# 348| Block 0 +# 348| v348_1(void) = EnterFunction : +# 348| m348_2(unknown) = AliasedDefinition : +# 348| mu348_3(unknown) = UnmodeledDefinition : +# 349| r349_1(glval) = VariableAddress[#return] : +# 349| r349_2(glval) = VariableAddress[g] : +# 349| r349_3(int *) = CopyValue : r349_2 +# 349| m349_4(int *) = Store : &:r349_1, r349_3 +# 348| r348_4(glval) = VariableAddress[#return] : +# 348| v348_5(void) = ReturnValue : &:r348_4, m349_4 +# 348| v348_6(void) = UnmodeledUse : mu* +# 348| v348_7(void) = AliasedUse : ~m348_2 +# 348| v348_8(void) = ExitFunction : + +# 352| void Break(int) +# 352| Block 0 +# 352| v352_1(void) = EnterFunction : +# 352| m352_2(unknown) = AliasedDefinition : +# 352| mu352_3(unknown) = UnmodeledDefinition : +# 352| r352_4(glval) = VariableAddress[n] : +# 352| m352_5(int) = InitializeParameter[n] : &:r352_4 +#-----| Goto -> Block 5 + +# 354| Block 1 +# 354| r354_1(glval) = VariableAddress[n] : +# 354| r354_2(int) = Load : &:r354_1, m353_1 +# 354| r354_3(int) = Constant[1] : +# 354| r354_4(bool) = CompareEQ : r354_2, r354_3 +# 354| v354_5(void) = ConditionalBranch : r354_4 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 355| Block 2 +# 355| v355_1(void) = NoOp : +#-----| Goto -> Block 4 + +# 356| Block 3 +# 356| r356_1(int) = Constant[1] : +# 356| r356_2(glval) = VariableAddress[n] : +# 356| r356_3(int) = Load : &:r356_2, m353_1 +# 356| r356_4(int) = Sub : r356_3, r356_1 +# 356| m356_5(int) = Store : &:r356_2, r356_4 +#-----| Goto (back edge) -> Block 5 + +# 357| Block 4 +# 357| v357_1(void) = NoOp : +# 358| v358_1(void) = NoOp : +# 352| v352_6(void) = ReturnVoid : +# 352| v352_7(void) = UnmodeledUse : mu* +# 352| v352_8(void) = AliasedUse : ~m352_2 +# 352| v352_9(void) = ExitFunction : + +# 353| Block 5 +# 353| m353_1(int) = Phi : from 0:m352_5, from 3:m356_5 +# 353| r353_2(glval) = VariableAddress[n] : +# 353| r353_3(int) = Load : &:r353_2, m353_1 +# 353| r353_4(int) = Constant[0] : +# 353| r353_5(bool) = CompareGT : r353_3, r353_4 +# 353| v353_6(void) = ConditionalBranch : r353_5 +#-----| False -> Block 4 +#-----| True -> Block 1 + +# 360| void Continue(int) +# 360| Block 0 +# 360| v360_1(void) = EnterFunction : +# 360| m360_2(unknown) = AliasedDefinition : +# 360| mu360_3(unknown) = UnmodeledDefinition : +# 360| r360_4(glval) = VariableAddress[n] : +# 360| m360_5(int) = InitializeParameter[n] : &:r360_4 +#-----| Goto -> Block 1 + +# 362| Block 1 +# 362| m362_1(int) = Phi : from 0:m360_5, from 4:m361_1 +# 362| r362_2(glval) = VariableAddress[n] : +# 362| r362_3(int) = Load : &:r362_2, m362_1 +# 362| r362_4(int) = Constant[1] : +# 362| r362_5(bool) = CompareEQ : r362_3, r362_4 +# 362| v362_6(void) = ConditionalBranch : r362_5 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 363| Block 2 +# 363| v363_1(void) = NoOp : +#-----| Goto -> Block 4 + +# 365| Block 3 +# 365| r365_1(int) = Constant[1] : +# 365| r365_2(glval) = VariableAddress[n] : +# 365| r365_3(int) = Load : &:r365_2, m362_1 +# 365| r365_4(int) = Sub : r365_3, r365_1 +# 365| m365_5(int) = Store : &:r365_2, r365_4 +#-----| Goto -> Block 4 + +# 361| Block 4 +# 361| m361_1(int) = Phi : from 2:m362_1, from 3:m365_5 +# 361| v361_2(void) = NoOp : +# 366| r366_1(glval) = VariableAddress[n] : +# 366| r366_2(int) = Load : &:r366_1, m361_1 +# 366| r366_3(int) = Constant[0] : +# 366| r366_4(bool) = CompareGT : r366_2, r366_3 +# 366| v366_5(void) = ConditionalBranch : r366_4 +#-----| False -> Block 5 +#-----| True (back edge) -> Block 1 + +# 367| Block 5 +# 367| v367_1(void) = NoOp : +# 360| v360_6(void) = ReturnVoid : +# 360| v360_7(void) = UnmodeledUse : mu* +# 360| v360_8(void) = AliasedUse : ~m360_2 +# 360| v360_9(void) = ExitFunction : + +# 372| void Call() +# 372| Block 0 +# 372| v372_1(void) = EnterFunction : +# 372| m372_2(unknown) = AliasedDefinition : +# 372| mu372_3(unknown) = UnmodeledDefinition : +# 373| r373_1(glval) = FunctionAddress[VoidFunc] : +# 373| v373_2(void) = Call : func:r373_1 +# 373| m373_3(unknown) = ^CallSideEffect : ~m372_2 +# 373| m373_4(unknown) = Chi : total:m372_2, partial:m373_3 +# 374| v374_1(void) = NoOp : +# 372| v372_4(void) = ReturnVoid : +# 372| v372_5(void) = UnmodeledUse : mu* +# 372| v372_6(void) = AliasedUse : ~m373_4 +# 372| v372_7(void) = ExitFunction : + +# 376| int CallAdd(int, int) +# 376| Block 0 +# 376| v376_1(void) = EnterFunction : +# 376| m376_2(unknown) = AliasedDefinition : +# 376| mu376_3(unknown) = UnmodeledDefinition : +# 376| r376_4(glval) = VariableAddress[x] : +# 376| m376_5(int) = InitializeParameter[x] : &:r376_4 +# 376| r376_6(glval) = VariableAddress[y] : +# 376| m376_7(int) = InitializeParameter[y] : &:r376_6 +# 377| r377_1(glval) = VariableAddress[#return] : +# 377| r377_2(glval) = FunctionAddress[Add] : +# 377| r377_3(glval) = VariableAddress[x] : +# 377| r377_4(int) = Load : &:r377_3, m376_5 +# 377| r377_5(glval) = VariableAddress[y] : +# 377| r377_6(int) = Load : &:r377_5, m376_7 +# 377| r377_7(int) = Call : func:r377_2, 0:r377_4, 1:r377_6 +# 377| m377_8(unknown) = ^CallSideEffect : ~m376_2 +# 377| m377_9(unknown) = Chi : total:m376_2, partial:m377_8 +# 377| m377_10(int) = Store : &:r377_1, r377_7 +# 376| r376_8(glval) = VariableAddress[#return] : +# 376| v376_9(void) = ReturnValue : &:r376_8, m377_10 +# 376| v376_10(void) = UnmodeledUse : mu* +# 376| v376_11(void) = AliasedUse : ~m377_9 +# 376| v376_12(void) = ExitFunction : + +# 380| int Comma(int, int) +# 380| Block 0 +# 380| v380_1(void) = EnterFunction : +# 380| m380_2(unknown) = AliasedDefinition : +# 380| mu380_3(unknown) = UnmodeledDefinition : +# 380| r380_4(glval) = VariableAddress[x] : +# 380| m380_5(int) = InitializeParameter[x] : &:r380_4 +# 380| r380_6(glval) = VariableAddress[y] : +# 380| m380_7(int) = InitializeParameter[y] : &:r380_6 +# 381| r381_1(glval) = VariableAddress[#return] : +# 381| r381_2(glval) = FunctionAddress[VoidFunc] : +# 381| v381_3(void) = Call : func:r381_2 +# 381| m381_4(unknown) = ^CallSideEffect : ~m380_2 +# 381| m381_5(unknown) = Chi : total:m380_2, partial:m381_4 +# 381| r381_6(glval) = FunctionAddress[CallAdd] : +# 381| r381_7(glval) = VariableAddress[x] : +# 381| r381_8(int) = Load : &:r381_7, m380_5 +# 381| r381_9(glval) = VariableAddress[y] : +# 381| r381_10(int) = Load : &:r381_9, m380_7 +# 381| r381_11(int) = Call : func:r381_6, 0:r381_8, 1:r381_10 +# 381| m381_12(unknown) = ^CallSideEffect : ~m381_5 +# 381| m381_13(unknown) = Chi : total:m381_5, partial:m381_12 +# 381| r381_14(int) = CopyValue : r381_11 +# 381| m381_15(int) = Store : &:r381_1, r381_14 +# 380| r380_8(glval) = VariableAddress[#return] : +# 380| v380_9(void) = ReturnValue : &:r380_8, m381_15 +# 380| v380_10(void) = UnmodeledUse : mu* +# 380| v380_11(void) = AliasedUse : ~m381_13 +# 380| v380_12(void) = ExitFunction : + +# 384| void Switch(int) +# 384| Block 0 +# 384| v384_1(void) = EnterFunction : +# 384| m384_2(unknown) = AliasedDefinition : +# 384| mu384_3(unknown) = UnmodeledDefinition : +# 384| r384_4(glval) = VariableAddress[x] : +# 384| m384_5(int) = InitializeParameter[x] : &:r384_4 +# 385| r385_1(glval) = VariableAddress[y] : +# 385| m385_2(int) = Uninitialized[y] : &:r385_1 +# 386| r386_1(glval) = VariableAddress[x] : +# 386| r386_2(int) = Load : &:r386_1, m384_5 +# 386| v386_3(void) = Switch : r386_2 +#-----| Case[-1] -> Block 1 +#-----| Case[1] -> Block 2 +#-----| Case[2] -> Block 3 +#-----| Case[3] -> Block 4 +#-----| Case[4] -> Block 5 +#-----| Default -> Block 6 + +# 389| Block 1 +# 389| v389_1(void) = NoOp : +# 390| r390_1(int) = Constant[-1] : +# 390| r390_2(glval) = VariableAddress[y] : +# 390| m390_3(int) = Store : &:r390_2, r390_1 +# 391| v391_1(void) = NoOp : +#-----| Goto -> Block 7 + +# 393| Block 2 +# 393| v393_1(void) = NoOp : +#-----| Goto -> Block 3 + +# 394| Block 3 +# 394| v394_1(void) = NoOp : +# 395| r395_1(int) = Constant[1] : +# 395| r395_2(glval) = VariableAddress[y] : +# 395| m395_3(int) = Store : &:r395_2, r395_1 +# 396| v396_1(void) = NoOp : +#-----| Goto -> Block 7 + +# 398| Block 4 +# 398| v398_1(void) = NoOp : +# 399| r399_1(int) = Constant[3] : +# 399| r399_2(glval) = VariableAddress[y] : +# 399| m399_3(int) = Store : &:r399_2, r399_1 +#-----| Goto -> Block 5 + +# 400| Block 5 +# 400| v400_1(void) = NoOp : +# 401| r401_1(int) = Constant[4] : +# 401| r401_2(glval) = VariableAddress[y] : +# 401| m401_3(int) = Store : &:r401_2, r401_1 +# 402| v402_1(void) = NoOp : +#-----| Goto -> Block 7 + +# 404| Block 6 +# 404| v404_1(void) = NoOp : +# 405| r405_1(int) = Constant[0] : +# 405| r405_2(glval) = VariableAddress[y] : +# 405| m405_3(int) = Store : &:r405_2, r405_1 +# 406| v406_1(void) = NoOp : +#-----| Goto -> Block 7 + +# 409| Block 7 +# 409| v409_1(void) = NoOp : +# 410| v410_1(void) = NoOp : +# 384| v384_6(void) = ReturnVoid : +# 384| v384_7(void) = UnmodeledUse : mu* +# 384| v384_8(void) = AliasedUse : ~m384_2 +# 384| v384_9(void) = ExitFunction : + +# 422| Point ReturnStruct(Point) +# 422| Block 0 +# 422| v422_1(void) = EnterFunction : +# 422| m422_2(unknown) = AliasedDefinition : +# 422| mu422_3(unknown) = UnmodeledDefinition : +# 422| r422_4(glval) = VariableAddress[pt] : +# 422| m422_5(Point) = InitializeParameter[pt] : &:r422_4 +# 423| r423_1(glval) = VariableAddress[#return] : +# 423| r423_2(glval) = VariableAddress[pt] : +# 423| r423_3(Point) = Load : &:r423_2, m422_5 +# 423| m423_4(Point) = Store : &:r423_1, r423_3 +# 422| r422_6(glval) = VariableAddress[#return] : +# 422| v422_7(void) = ReturnValue : &:r422_6, m423_4 +# 422| v422_8(void) = UnmodeledUse : mu* +# 422| v422_9(void) = AliasedUse : ~m422_2 +# 422| v422_10(void) = ExitFunction : + +# 426| void FieldAccess() +# 426| Block 0 +# 426| v426_1(void) = EnterFunction : +# 426| m426_2(unknown) = AliasedDefinition : +# 426| mu426_3(unknown) = UnmodeledDefinition : +# 427| r427_1(glval) = VariableAddress[pt] : +# 427| m427_2(Point) = Uninitialized[pt] : &:r427_1 +# 428| r428_1(int) = Constant[5] : +# 428| r428_2(glval) = VariableAddress[pt] : +# 428| r428_3(glval) = FieldAddress[x] : r428_2 +# 428| m428_4(int) = Store : &:r428_3, r428_1 +# 428| m428_5(Point) = Chi : total:m427_2, partial:m428_4 +# 429| r429_1(glval) = VariableAddress[pt] : +# 429| r429_2(glval) = FieldAddress[x] : r429_1 +# 429| r429_3(int) = Load : &:r429_2, m428_4 +# 429| r429_4(glval) = VariableAddress[pt] : +# 429| r429_5(glval) = FieldAddress[y] : r429_4 +# 429| m429_6(int) = Store : &:r429_5, r429_3 +# 429| m429_7(Point) = Chi : total:m428_5, partial:m429_6 +# 430| r430_1(glval) = VariableAddress[p] : +# 430| r430_2(glval) = VariableAddress[pt] : +# 430| r430_3(glval) = FieldAddress[y] : r430_2 +# 430| r430_4(int *) = CopyValue : r430_3 +# 430| m430_5(int *) = Store : &:r430_1, r430_4 +# 431| v431_1(void) = NoOp : +# 426| v426_4(void) = ReturnVoid : +# 426| v426_5(void) = UnmodeledUse : mu* +# 426| v426_6(void) = AliasedUse : ~m426_2 +# 426| v426_7(void) = ExitFunction : + +# 433| void LogicalOr(bool, bool) +# 433| Block 0 +# 433| v433_1(void) = EnterFunction : +# 433| m433_2(unknown) = AliasedDefinition : +# 433| mu433_3(unknown) = UnmodeledDefinition : +# 433| r433_4(glval) = VariableAddress[a] : +# 433| m433_5(bool) = InitializeParameter[a] : &:r433_4 +# 433| r433_6(glval) = VariableAddress[b] : +# 433| m433_7(bool) = InitializeParameter[b] : &:r433_6 +# 434| r434_1(glval) = VariableAddress[x] : +# 434| m434_2(int) = Uninitialized[x] : &:r434_1 +# 435| r435_1(glval) = VariableAddress[a] : +# 435| r435_2(bool) = Load : &:r435_1, m433_5 +# 435| v435_3(void) = ConditionalBranch : r435_2 +#-----| False -> Block 1 +#-----| True -> Block 2 + +# 435| Block 1 +# 435| r435_4(glval) = VariableAddress[b] : +# 435| r435_5(bool) = Load : &:r435_4, m433_7 +# 435| v435_6(void) = ConditionalBranch : r435_5 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 436| Block 2 +# 436| r436_1(int) = Constant[7] : +# 436| r436_2(glval) = VariableAddress[x] : +# 436| m436_3(int) = Store : &:r436_2, r436_1 +#-----| Goto -> Block 3 + +# 439| Block 3 +# 439| r439_1(glval) = VariableAddress[a] : +# 439| r439_2(bool) = Load : &:r439_1, m433_5 +# 439| v439_3(void) = ConditionalBranch : r439_2 +#-----| False -> Block 4 +#-----| True -> Block 5 + +# 439| Block 4 +# 439| r439_4(glval) = VariableAddress[b] : +# 439| r439_5(bool) = Load : &:r439_4, m433_7 +# 439| v439_6(void) = ConditionalBranch : r439_5 +#-----| False -> Block 6 +#-----| True -> Block 5 + +# 440| Block 5 +# 440| r440_1(int) = Constant[1] : +# 440| r440_2(glval) = VariableAddress[x] : +# 440| m440_3(int) = Store : &:r440_2, r440_1 +#-----| Goto -> Block 7 + +# 443| Block 6 +# 443| r443_1(int) = Constant[5] : +# 443| r443_2(glval) = VariableAddress[x] : +# 443| m443_3(int) = Store : &:r443_2, r443_1 +#-----| Goto -> Block 7 + +# 445| Block 7 +# 445| v445_1(void) = NoOp : +# 433| v433_8(void) = ReturnVoid : +# 433| v433_9(void) = UnmodeledUse : mu* +# 433| v433_10(void) = AliasedUse : ~m433_2 +# 433| v433_11(void) = ExitFunction : + +# 447| void LogicalAnd(bool, bool) +# 447| Block 0 +# 447| v447_1(void) = EnterFunction : +# 447| m447_2(unknown) = AliasedDefinition : +# 447| mu447_3(unknown) = UnmodeledDefinition : +# 447| r447_4(glval) = VariableAddress[a] : +# 447| m447_5(bool) = InitializeParameter[a] : &:r447_4 +# 447| r447_6(glval) = VariableAddress[b] : +# 447| m447_7(bool) = InitializeParameter[b] : &:r447_6 +# 448| r448_1(glval) = VariableAddress[x] : +# 448| m448_2(int) = Uninitialized[x] : &:r448_1 +# 449| r449_1(glval) = VariableAddress[a] : +# 449| r449_2(bool) = Load : &:r449_1, m447_5 +# 449| v449_3(void) = ConditionalBranch : r449_2 +#-----| False -> Block 3 +#-----| True -> Block 1 + +# 449| Block 1 +# 449| r449_4(glval) = VariableAddress[b] : +# 449| r449_5(bool) = Load : &:r449_4, m447_7 +# 449| v449_6(void) = ConditionalBranch : r449_5 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 450| Block 2 +# 450| r450_1(int) = Constant[7] : +# 450| r450_2(glval) = VariableAddress[x] : +# 450| m450_3(int) = Store : &:r450_2, r450_1 +#-----| Goto -> Block 3 + +# 453| Block 3 +# 453| r453_1(glval) = VariableAddress[a] : +# 453| r453_2(bool) = Load : &:r453_1, m447_5 +# 453| v453_3(void) = ConditionalBranch : r453_2 +#-----| False -> Block 6 +#-----| True -> Block 4 + +# 453| Block 4 +# 453| r453_4(glval) = VariableAddress[b] : +# 453| r453_5(bool) = Load : &:r453_4, m447_7 +# 453| v453_6(void) = ConditionalBranch : r453_5 +#-----| False -> Block 6 +#-----| True -> Block 5 + +# 454| Block 5 +# 454| r454_1(int) = Constant[1] : +# 454| r454_2(glval) = VariableAddress[x] : +# 454| m454_3(int) = Store : &:r454_2, r454_1 +#-----| Goto -> Block 7 + +# 457| Block 6 +# 457| r457_1(int) = Constant[5] : +# 457| r457_2(glval) = VariableAddress[x] : +# 457| m457_3(int) = Store : &:r457_2, r457_1 +#-----| Goto -> Block 7 + +# 459| Block 7 +# 459| v459_1(void) = NoOp : +# 447| v447_8(void) = ReturnVoid : +# 447| v447_9(void) = UnmodeledUse : mu* +# 447| v447_10(void) = AliasedUse : ~m447_2 +# 447| v447_11(void) = ExitFunction : + +# 461| void LogicalNot(bool, bool) +# 461| Block 0 +# 461| v461_1(void) = EnterFunction : +# 461| m461_2(unknown) = AliasedDefinition : +# 461| mu461_3(unknown) = UnmodeledDefinition : +# 461| r461_4(glval) = VariableAddress[a] : +# 461| m461_5(bool) = InitializeParameter[a] : &:r461_4 +# 461| r461_6(glval) = VariableAddress[b] : +# 461| m461_7(bool) = InitializeParameter[b] : &:r461_6 +# 462| r462_1(glval) = VariableAddress[x] : +# 462| m462_2(int) = Uninitialized[x] : &:r462_1 +# 463| r463_1(glval) = VariableAddress[a] : +# 463| r463_2(bool) = Load : &:r463_1, m461_5 +# 463| v463_3(void) = ConditionalBranch : r463_2 +#-----| False -> Block 1 +#-----| True -> Block 2 + +# 464| Block 1 +# 464| r464_1(int) = Constant[1] : +# 464| r464_2(glval) = VariableAddress[x] : +# 464| m464_3(int) = Store : &:r464_2, r464_1 +#-----| Goto -> Block 2 + +# 467| Block 2 +# 467| r467_1(glval) = VariableAddress[a] : +# 467| r467_2(bool) = Load : &:r467_1, m461_5 +# 467| v467_3(void) = ConditionalBranch : r467_2 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 467| Block 3 +# 467| r467_4(glval) = VariableAddress[b] : +# 467| r467_5(bool) = Load : &:r467_4, m461_7 +# 467| v467_6(void) = ConditionalBranch : r467_5 +#-----| False -> Block 4 +#-----| True -> Block 5 + +# 468| Block 4 +# 468| r468_1(int) = Constant[2] : +# 468| r468_2(glval) = VariableAddress[x] : +# 468| m468_3(int) = Store : &:r468_2, r468_1 +#-----| Goto -> Block 6 + +# 471| Block 5 +# 471| r471_1(int) = Constant[3] : +# 471| r471_2(glval) = VariableAddress[x] : +# 471| m471_3(int) = Store : &:r471_2, r471_1 +#-----| Goto -> Block 6 + +# 473| Block 6 +# 473| v473_1(void) = NoOp : +# 461| v461_8(void) = ReturnVoid : +# 461| v461_9(void) = UnmodeledUse : mu* +# 461| v461_10(void) = AliasedUse : ~m461_2 +# 461| v461_11(void) = ExitFunction : + +# 475| void ConditionValues(bool, bool) +# 475| Block 0 +# 475| v475_1(void) = EnterFunction : +# 475| m475_2(unknown) = AliasedDefinition : +# 475| mu475_3(unknown) = UnmodeledDefinition : +# 475| r475_4(glval) = VariableAddress[a] : +# 475| m475_5(bool) = InitializeParameter[a] : &:r475_4 +# 475| r475_6(glval) = VariableAddress[b] : +# 475| m475_7(bool) = InitializeParameter[b] : &:r475_6 +# 476| r476_1(glval) = VariableAddress[x] : +# 476| m476_2(bool) = Uninitialized[x] : &:r476_1 +# 477| r477_1(glval) = VariableAddress[a] : +# 477| r477_2(bool) = Load : &:r477_1, m475_5 +# 477| v477_3(void) = ConditionalBranch : r477_2 +#-----| False -> Block 10 +#-----| True -> Block 1 + +# 477| Block 1 +# 477| r477_4(glval) = VariableAddress[b] : +# 477| r477_5(bool) = Load : &:r477_4, m475_7 +# 477| v477_6(void) = ConditionalBranch : r477_5 +#-----| False -> Block 10 +#-----| True -> Block 12 + +# 478| Block 2 +# 478| r478_1(glval) = VariableAddress[#temp478:9] : +# 478| r478_2(bool) = Constant[0] : +# 478| m478_3(bool) = Store : &:r478_1, r478_2 +#-----| Goto -> Block 3 + +# 478| Block 3 +# 478| m478_4(bool) = Phi : from 2:m478_3, from 4:m478_11 +# 478| r478_5(glval) = VariableAddress[#temp478:9] : +# 478| r478_6(bool) = Load : &:r478_5, m478_4 +# 478| r478_7(glval) = VariableAddress[x] : +# 478| m478_8(bool) = Store : &:r478_7, r478_6 +# 479| r479_1(glval) = VariableAddress[a] : +# 479| r479_2(bool) = Load : &:r479_1, m475_5 +# 479| v479_3(void) = ConditionalBranch : r479_2 +#-----| False -> Block 9 +#-----| True -> Block 8 + +# 478| Block 4 +# 478| r478_9(glval) = VariableAddress[#temp478:9] : +# 478| r478_10(bool) = Constant[1] : +# 478| m478_11(bool) = Store : &:r478_9, r478_10 +#-----| Goto -> Block 3 + +# 478| Block 5 +# 478| r478_12(glval) = VariableAddress[b] : +# 478| r478_13(bool) = Load : &:r478_12, m475_7 +# 478| v478_14(void) = ConditionalBranch : r478_13 +#-----| False -> Block 2 +#-----| True -> Block 4 + +# 479| Block 6 +# 479| r479_4(glval) = VariableAddress[#temp479:11] : +# 479| r479_5(bool) = Constant[0] : +# 479| m479_6(bool) = Store : &:r479_4, r479_5 +#-----| Goto -> Block 7 + +# 479| Block 7 +# 479| m479_7(bool) = Phi : from 6:m479_6, from 8:m479_15 +# 479| r479_8(glval) = VariableAddress[#temp479:11] : +# 479| r479_9(bool) = Load : &:r479_8, m479_7 +# 479| r479_10(bool) = LogicalNot : r479_9 +# 479| r479_11(glval) = VariableAddress[x] : +# 479| m479_12(bool) = Store : &:r479_11, r479_10 +# 480| v480_1(void) = NoOp : +# 475| v475_8(void) = ReturnVoid : +# 475| v475_9(void) = UnmodeledUse : mu* +# 475| v475_10(void) = AliasedUse : ~m475_2 +# 475| v475_11(void) = ExitFunction : + +# 479| Block 8 +# 479| r479_13(glval) = VariableAddress[#temp479:11] : +# 479| r479_14(bool) = Constant[1] : +# 479| m479_15(bool) = Store : &:r479_13, r479_14 +#-----| Goto -> Block 7 + +# 479| Block 9 +# 479| r479_16(glval) = VariableAddress[b] : +# 479| r479_17(bool) = Load : &:r479_16, m475_7 +# 479| v479_18(void) = ConditionalBranch : r479_17 +#-----| False -> Block 6 +#-----| True -> Block 8 + +# 477| Block 10 +# 477| r477_7(glval) = VariableAddress[#temp477:9] : +# 477| r477_8(bool) = Constant[0] : +# 477| m477_9(bool) = Store : &:r477_7, r477_8 +#-----| Goto -> Block 11 + +# 477| Block 11 +# 477| m477_10(bool) = Phi : from 10:m477_9, from 12:m477_17 +# 477| r477_11(glval) = VariableAddress[#temp477:9] : +# 477| r477_12(bool) = Load : &:r477_11, m477_10 +# 477| r477_13(glval) = VariableAddress[x] : +# 477| m477_14(bool) = Store : &:r477_13, r477_12 +# 478| r478_15(glval) = VariableAddress[a] : +# 478| r478_16(bool) = Load : &:r478_15, m475_5 +# 478| v478_17(void) = ConditionalBranch : r478_16 +#-----| False -> Block 5 +#-----| True -> Block 4 + +# 477| Block 12 +# 477| r477_15(glval) = VariableAddress[#temp477:9] : +# 477| r477_16(bool) = Constant[1] : +# 477| m477_17(bool) = Store : &:r477_15, r477_16 +#-----| Goto -> Block 11 + +# 482| void Conditional(bool, int, int) +# 482| Block 0 +# 482| v482_1(void) = EnterFunction : +# 482| m482_2(unknown) = AliasedDefinition : +# 482| mu482_3(unknown) = UnmodeledDefinition : +# 482| r482_4(glval) = VariableAddress[a] : +# 482| m482_5(bool) = InitializeParameter[a] : &:r482_4 +# 482| r482_6(glval) = VariableAddress[x] : +# 482| m482_7(int) = InitializeParameter[x] : &:r482_6 +# 482| r482_8(glval) = VariableAddress[y] : +# 482| m482_9(int) = InitializeParameter[y] : &:r482_8 +# 483| r483_1(glval) = VariableAddress[z] : +# 483| r483_2(glval) = VariableAddress[a] : +# 483| r483_3(bool) = Load : &:r483_2, m482_5 +# 483| v483_4(void) = ConditionalBranch : r483_3 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 483| Block 1 +# 483| r483_5(glval) = VariableAddress[x] : +# 483| r483_6(int) = Load : &:r483_5, m482_7 +# 483| r483_7(glval) = VariableAddress[#temp483:13] : +# 483| m483_8(int) = Store : &:r483_7, r483_6 +#-----| Goto -> Block 3 + +# 483| Block 2 +# 483| r483_9(glval) = VariableAddress[y] : +# 483| r483_10(int) = Load : &:r483_9, m482_9 +# 483| r483_11(glval) = VariableAddress[#temp483:13] : +# 483| m483_12(int) = Store : &:r483_11, r483_10 +#-----| Goto -> Block 3 + +# 483| Block 3 +# 483| m483_13(int) = Phi : from 1:m483_8, from 2:m483_12 +# 483| r483_14(glval) = VariableAddress[#temp483:13] : +# 483| r483_15(int) = Load : &:r483_14, m483_13 +# 483| m483_16(int) = Store : &:r483_1, r483_15 +# 484| v484_1(void) = NoOp : +# 482| v482_10(void) = ReturnVoid : +# 482| v482_11(void) = UnmodeledUse : mu* +# 482| v482_12(void) = AliasedUse : ~m482_2 +# 482| v482_13(void) = ExitFunction : + +# 486| void Conditional_LValue(bool) +# 486| Block 0 +# 486| v486_1(void) = EnterFunction : +# 486| m486_2(unknown) = AliasedDefinition : +# 486| mu486_3(unknown) = UnmodeledDefinition : +# 486| r486_4(glval) = VariableAddress[a] : +# 486| m486_5(bool) = InitializeParameter[a] : &:r486_4 +# 487| r487_1(glval) = VariableAddress[x] : +# 487| m487_2(int) = Uninitialized[x] : &:r487_1 +# 488| r488_1(glval) = VariableAddress[y] : +# 488| m488_2(int) = Uninitialized[y] : &:r488_1 +# 489| r489_1(int) = Constant[5] : +# 489| r489_2(glval) = VariableAddress[a] : +# 489| r489_3(bool) = Load : &:r489_2, m486_5 +# 489| v489_4(void) = ConditionalBranch : r489_3 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 489| Block 1 +# 489| m489_5(glval) = Phi : from 2:m489_12, from 3:m489_15 +# 489| r489_6(glval) = VariableAddress[#temp489:6] : +# 489| r489_7(glval) = Load : &:r489_6, m489_5 +# 489| m489_8(int) = Store : &:r489_7, r489_1 +# 489| m489_9(unknown) = Chi : total:m486_2, partial:m489_8 +# 490| v490_1(void) = NoOp : +# 486| v486_6(void) = ReturnVoid : +# 486| v486_7(void) = UnmodeledUse : mu* +# 486| v486_8(void) = AliasedUse : ~m489_9 +# 486| v486_9(void) = ExitFunction : + +# 489| Block 2 +# 489| r489_10(glval) = VariableAddress[x] : +# 489| r489_11(glval) = VariableAddress[#temp489:6] : +# 489| m489_12(glval) = Store : &:r489_11, r489_10 +#-----| Goto -> Block 1 + +# 489| Block 3 +# 489| r489_13(glval) = VariableAddress[y] : +# 489| r489_14(glval) = VariableAddress[#temp489:6] : +# 489| m489_15(glval) = Store : &:r489_14, r489_13 +#-----| Goto -> Block 1 + +# 492| void Conditional_Void(bool) +# 492| Block 0 +# 492| v492_1(void) = EnterFunction : +# 492| m492_2(unknown) = AliasedDefinition : +# 492| mu492_3(unknown) = UnmodeledDefinition : +# 492| r492_4(glval) = VariableAddress[a] : +# 492| m492_5(bool) = InitializeParameter[a] : &:r492_4 +# 493| r493_1(glval) = VariableAddress[a] : +# 493| r493_2(bool) = Load : &:r493_1, m492_5 +# 493| v493_3(void) = ConditionalBranch : r493_2 +#-----| False -> Block 1 +#-----| True -> Block 3 + +# 493| Block 1 +# 493| r493_4(glval) = FunctionAddress[VoidFunc] : +# 493| v493_5(void) = Call : func:r493_4 +# 493| m493_6(unknown) = ^CallSideEffect : ~m492_2 +# 493| m493_7(unknown) = Chi : total:m492_2, partial:m493_6 +#-----| Goto -> Block 2 + +# 494| Block 2 +# 494| m494_1(unknown) = Phi : from 1:~m493_7, from 3:~m493_11 +# 494| v494_2(void) = NoOp : +# 492| v492_6(void) = ReturnVoid : +# 492| v492_7(void) = UnmodeledUse : mu* +# 492| v492_8(void) = AliasedUse : ~m494_1 +# 492| v492_9(void) = ExitFunction : + +# 493| Block 3 +# 493| r493_8(glval) = FunctionAddress[VoidFunc] : +# 493| v493_9(void) = Call : func:r493_8 +# 493| m493_10(unknown) = ^CallSideEffect : ~m492_2 +# 493| m493_11(unknown) = Chi : total:m492_2, partial:m493_10 +#-----| Goto -> Block 2 + +# 496| void Nullptr() +# 496| Block 0 +# 496| v496_1(void) = EnterFunction : +# 496| m496_2(unknown) = AliasedDefinition : +# 496| mu496_3(unknown) = UnmodeledDefinition : +# 497| r497_1(glval) = VariableAddress[p] : +# 497| r497_2(int *) = Constant[0] : +# 497| m497_3(int *) = Store : &:r497_1, r497_2 +# 498| r498_1(glval) = VariableAddress[q] : +# 498| r498_2(int *) = Constant[0] : +# 498| m498_3(int *) = Store : &:r498_1, r498_2 +# 499| r499_1(int *) = Constant[0] : +# 499| r499_2(glval) = VariableAddress[p] : +# 499| m499_3(int *) = Store : &:r499_2, r499_1 +# 500| r500_1(int *) = Constant[0] : +# 500| r500_2(glval) = VariableAddress[q] : +# 500| m500_3(int *) = Store : &:r500_2, r500_1 +# 501| v501_1(void) = NoOp : +# 496| v496_4(void) = ReturnVoid : +# 496| v496_5(void) = UnmodeledUse : mu* +# 496| v496_6(void) = AliasedUse : ~m496_2 +# 496| v496_7(void) = ExitFunction : + +# 503| void InitList(int, float) +# 503| Block 0 +# 503| v503_1(void) = EnterFunction : +# 503| m503_2(unknown) = AliasedDefinition : +# 503| mu503_3(unknown) = UnmodeledDefinition : +# 503| r503_4(glval) = VariableAddress[x] : +# 503| m503_5(int) = InitializeParameter[x] : &:r503_4 +# 503| r503_6(glval) = VariableAddress[f] : +# 503| m503_7(float) = InitializeParameter[f] : &:r503_6 +# 504| r504_1(glval) = VariableAddress[pt1] : +# 504| m504_2(Point) = Uninitialized[pt1] : &:r504_1 +# 504| r504_3(glval) = FieldAddress[x] : r504_1 +# 504| r504_4(glval) = VariableAddress[x] : +# 504| r504_5(int) = Load : &:r504_4, m503_5 +# 504| m504_6(int) = Store : &:r504_3, r504_5 +# 504| m504_7(Point) = Chi : total:m504_2, partial:m504_6 +# 504| r504_8(glval) = FieldAddress[y] : r504_1 +# 504| r504_9(glval) = VariableAddress[f] : +# 504| r504_10(float) = Load : &:r504_9, m503_7 +# 504| r504_11(int) = Convert : r504_10 +# 504| m504_12(int) = Store : &:r504_8, r504_11 +# 504| m504_13(Point) = Chi : total:m504_7, partial:m504_12 +# 505| r505_1(glval) = VariableAddress[pt2] : +# 505| m505_2(Point) = Uninitialized[pt2] : &:r505_1 +# 505| r505_3(glval) = FieldAddress[x] : r505_1 +# 505| r505_4(glval) = VariableAddress[x] : +# 505| r505_5(int) = Load : &:r505_4, m503_5 +# 505| m505_6(int) = Store : &:r505_3, r505_5 +# 505| m505_7(Point) = Chi : total:m505_2, partial:m505_6 +# 505| r505_8(glval) = FieldAddress[y] : r505_1 +# 505| r505_9(int) = Constant[0] : +# 505| m505_10(int) = Store : &:r505_8, r505_9 +# 505| m505_11(Point) = Chi : total:m505_7, partial:m505_10 +# 506| r506_1(glval) = VariableAddress[pt3] : +# 506| m506_2(Point) = Uninitialized[pt3] : &:r506_1 +# 506| r506_3(glval) = FieldAddress[x] : r506_1 +# 506| r506_4(int) = Constant[0] : +# 506| m506_5(int) = Store : &:r506_3, r506_4 +# 506| m506_6(Point) = Chi : total:m506_2, partial:m506_5 +# 506| r506_7(glval) = FieldAddress[y] : r506_1 +# 506| r506_8(int) = Constant[0] : +# 506| m506_9(int) = Store : &:r506_7, r506_8 +# 506| m506_10(Point) = Chi : total:m506_6, partial:m506_9 +# 508| r508_1(glval) = VariableAddress[x1] : +# 508| r508_2(int) = Constant[1] : +# 508| m508_3(int) = Store : &:r508_1, r508_2 +# 509| r509_1(glval) = VariableAddress[x2] : +# 509| r509_2(int) = Constant[0] : +# 509| m509_3(int) = Store : &:r509_1, r509_2 +# 510| v510_1(void) = NoOp : +# 503| v503_8(void) = ReturnVoid : +# 503| v503_9(void) = UnmodeledUse : mu* +# 503| v503_10(void) = AliasedUse : ~m503_2 +# 503| v503_11(void) = ExitFunction : + +# 512| void NestedInitList(int, float) +# 512| Block 0 +# 512| v512_1(void) = EnterFunction : +# 512| m512_2(unknown) = AliasedDefinition : +# 512| mu512_3(unknown) = UnmodeledDefinition : +# 512| r512_4(glval) = VariableAddress[x] : +# 512| m512_5(int) = InitializeParameter[x] : &:r512_4 +# 512| r512_6(glval) = VariableAddress[f] : +# 512| m512_7(float) = InitializeParameter[f] : &:r512_6 +# 513| r513_1(glval) = VariableAddress[r1] : +# 513| m513_2(Rect) = Uninitialized[r1] : &:r513_1 +# 513| r513_3(glval) = FieldAddress[topLeft] : r513_1 +# 513| r513_4(Point) = Constant[0] : +# 513| m513_5(Point) = Store : &:r513_3, r513_4 +# 513| m513_6(Rect) = Chi : total:m513_2, partial:m513_5 +# 513| r513_7(glval) = FieldAddress[bottomRight] : r513_1 +# 513| r513_8(Point) = Constant[0] : +# 513| m513_9(Point) = Store : &:r513_7, r513_8 +# 513| m513_10(Rect) = Chi : total:m513_6, partial:m513_9 +# 514| r514_1(glval) = VariableAddress[r2] : +# 514| m514_2(Rect) = Uninitialized[r2] : &:r514_1 +# 514| r514_3(glval) = FieldAddress[topLeft] : r514_1 +# 514| r514_4(glval) = FieldAddress[x] : r514_3 +# 514| r514_5(glval) = VariableAddress[x] : +# 514| r514_6(int) = Load : &:r514_5, m512_5 +# 514| m514_7(int) = Store : &:r514_4, r514_6 +# 514| m514_8(Rect) = Chi : total:m514_2, partial:m514_7 +# 514| r514_9(glval) = FieldAddress[y] : r514_3 +# 514| r514_10(glval) = VariableAddress[f] : +# 514| r514_11(float) = Load : &:r514_10, m512_7 +# 514| r514_12(int) = Convert : r514_11 +# 514| m514_13(int) = Store : &:r514_9, r514_12 +# 514| m514_14(Rect) = Chi : total:m514_8, partial:m514_13 +# 514| r514_15(glval) = FieldAddress[bottomRight] : r514_1 +# 514| r514_16(Point) = Constant[0] : +# 514| m514_17(Point) = Store : &:r514_15, r514_16 +# 514| m514_18(Rect) = Chi : total:m514_14, partial:m514_17 +# 515| r515_1(glval) = VariableAddress[r3] : +# 515| m515_2(Rect) = Uninitialized[r3] : &:r515_1 +# 515| r515_3(glval) = FieldAddress[topLeft] : r515_1 +# 515| r515_4(glval) = FieldAddress[x] : r515_3 +# 515| r515_5(glval) = VariableAddress[x] : +# 515| r515_6(int) = Load : &:r515_5, m512_5 +# 515| m515_7(int) = Store : &:r515_4, r515_6 +# 515| m515_8(Rect) = Chi : total:m515_2, partial:m515_7 +# 515| r515_9(glval) = FieldAddress[y] : r515_3 +# 515| r515_10(glval) = VariableAddress[f] : +# 515| r515_11(float) = Load : &:r515_10, m512_7 +# 515| r515_12(int) = Convert : r515_11 +# 515| m515_13(int) = Store : &:r515_9, r515_12 +# 515| m515_14(Rect) = Chi : total:m515_8, partial:m515_13 +# 515| r515_15(glval) = FieldAddress[bottomRight] : r515_1 +# 515| r515_16(glval) = FieldAddress[x] : r515_15 +# 515| r515_17(glval) = VariableAddress[x] : +# 515| r515_18(int) = Load : &:r515_17, m512_5 +# 515| m515_19(int) = Store : &:r515_16, r515_18 +# 515| m515_20(Rect) = Chi : total:m515_14, partial:m515_19 +# 515| r515_21(glval) = FieldAddress[y] : r515_15 +# 515| r515_22(glval) = VariableAddress[f] : +# 515| r515_23(float) = Load : &:r515_22, m512_7 +# 515| r515_24(int) = Convert : r515_23 +# 515| m515_25(int) = Store : &:r515_21, r515_24 +# 515| m515_26(Rect) = Chi : total:m515_20, partial:m515_25 +# 516| r516_1(glval) = VariableAddress[r4] : +# 516| m516_2(Rect) = Uninitialized[r4] : &:r516_1 +# 516| r516_3(glval) = FieldAddress[topLeft] : r516_1 +# 516| r516_4(glval) = FieldAddress[x] : r516_3 +# 516| r516_5(glval) = VariableAddress[x] : +# 516| r516_6(int) = Load : &:r516_5, m512_5 +# 516| m516_7(int) = Store : &:r516_4, r516_6 +# 516| m516_8(Rect) = Chi : total:m516_2, partial:m516_7 +# 516| r516_9(glval) = FieldAddress[y] : r516_3 +# 516| r516_10(int) = Constant[0] : +# 516| m516_11(int) = Store : &:r516_9, r516_10 +# 516| m516_12(Rect) = Chi : total:m516_8, partial:m516_11 +# 516| r516_13(glval) = FieldAddress[bottomRight] : r516_1 +# 516| r516_14(glval) = FieldAddress[x] : r516_13 +# 516| r516_15(glval) = VariableAddress[x] : +# 516| r516_16(int) = Load : &:r516_15, m512_5 +# 516| m516_17(int) = Store : &:r516_14, r516_16 +# 516| m516_18(Rect) = Chi : total:m516_12, partial:m516_17 +# 516| r516_19(glval) = FieldAddress[y] : r516_13 +# 516| r516_20(int) = Constant[0] : +# 516| m516_21(int) = Store : &:r516_19, r516_20 +# 516| m516_22(Rect) = Chi : total:m516_18, partial:m516_21 +# 517| v517_1(void) = NoOp : +# 512| v512_8(void) = ReturnVoid : +# 512| v512_9(void) = UnmodeledUse : mu* +# 512| v512_10(void) = AliasedUse : ~m512_2 +# 512| v512_11(void) = ExitFunction : + +# 519| void ArrayInit(int, float) +# 519| Block 0 +# 519| v519_1(void) = EnterFunction : +# 519| m519_2(unknown) = AliasedDefinition : +# 519| mu519_3(unknown) = UnmodeledDefinition : +# 519| r519_4(glval) = VariableAddress[x] : +# 519| m519_5(int) = InitializeParameter[x] : &:r519_4 +# 519| r519_6(glval) = VariableAddress[f] : +# 519| m519_7(float) = InitializeParameter[f] : &:r519_6 +# 520| r520_1(glval) = VariableAddress[a1] : +# 520| m520_2(int[3]) = Uninitialized[a1] : &:r520_1 +# 520| r520_3(int) = Constant[0] : +# 520| r520_4(glval) = PointerAdd[4] : r520_1, r520_3 +# 520| r520_5(unknown[12]) = Constant[0] : +# 520| m520_6(unknown[12]) = Store : &:r520_4, r520_5 +# 521| r521_1(glval) = VariableAddress[a2] : +# 521| m521_2(int[3]) = Uninitialized[a2] : &:r521_1 +# 521| r521_3(int) = Constant[0] : +# 521| r521_4(glval) = PointerAdd[4] : r521_1, r521_3 +# 521| r521_5(glval) = VariableAddress[x] : +# 521| r521_6(int) = Load : &:r521_5, m519_5 +# 521| m521_7(int) = Store : &:r521_4, r521_6 +# 521| m521_8(int[3]) = Chi : total:m521_2, partial:m521_7 +# 521| r521_9(int) = Constant[1] : +# 521| r521_10(glval) = PointerAdd[4] : r521_1, r521_9 +# 521| r521_11(glval) = VariableAddress[f] : +# 521| r521_12(float) = Load : &:r521_11, m519_7 +# 521| r521_13(int) = Convert : r521_12 +# 521| m521_14(int) = Store : &:r521_10, r521_13 +# 521| m521_15(int[3]) = Chi : total:m521_8, partial:m521_14 +# 521| r521_16(int) = Constant[2] : +# 521| r521_17(glval) = PointerAdd[4] : r521_1, r521_16 +# 521| r521_18(int) = Constant[0] : +# 521| m521_19(int) = Store : &:r521_17, r521_18 +# 521| m521_20(int[3]) = Chi : total:m521_15, partial:m521_19 +# 522| r522_1(glval) = VariableAddress[a3] : +# 522| m522_2(int[3]) = Uninitialized[a3] : &:r522_1 +# 522| r522_3(int) = Constant[0] : +# 522| r522_4(glval) = PointerAdd[4] : r522_1, r522_3 +# 522| r522_5(glval) = VariableAddress[x] : +# 522| r522_6(int) = Load : &:r522_5, m519_5 +# 522| m522_7(int) = Store : &:r522_4, r522_6 +# 522| m522_8(int[3]) = Chi : total:m522_2, partial:m522_7 +# 522| r522_9(int) = Constant[1] : +# 522| r522_10(glval) = PointerAdd[4] : r522_1, r522_9 +# 522| r522_11(unknown[8]) = Constant[0] : +# 522| m522_12(unknown[8]) = Store : &:r522_10, r522_11 +# 522| m522_13(int[3]) = Chi : total:m522_8, partial:m522_12 +# 523| v523_1(void) = NoOp : +# 519| v519_8(void) = ReturnVoid : +# 519| v519_9(void) = UnmodeledUse : mu* +# 519| v519_10(void) = AliasedUse : ~m519_2 +# 519| v519_11(void) = ExitFunction : + +# 530| void UnionInit(int, float) +# 530| Block 0 +# 530| v530_1(void) = EnterFunction : +# 530| m530_2(unknown) = AliasedDefinition : +# 530| mu530_3(unknown) = UnmodeledDefinition : +# 530| r530_4(glval) = VariableAddress[x] : +# 530| m530_5(int) = InitializeParameter[x] : &:r530_4 +# 530| r530_6(glval) = VariableAddress[f] : +# 530| m530_7(float) = InitializeParameter[f] : &:r530_6 +# 531| r531_1(glval) = VariableAddress[u1] : +# 531| m531_2(U) = Uninitialized[u1] : &:r531_1 +# 531| r531_3(glval) = FieldAddress[d] : r531_1 +# 531| r531_4(glval) = VariableAddress[f] : +# 531| r531_5(float) = Load : &:r531_4, m530_7 +# 531| r531_6(double) = Convert : r531_5 +# 531| m531_7(double) = Store : &:r531_3, r531_6 +# 533| v533_1(void) = NoOp : +# 530| v530_8(void) = ReturnVoid : +# 530| v530_9(void) = UnmodeledUse : mu* +# 530| v530_10(void) = AliasedUse : ~m530_2 +# 530| v530_11(void) = ExitFunction : + +# 535| void EarlyReturn(int, int) +# 535| Block 0 +# 535| v535_1(void) = EnterFunction : +# 535| m535_2(unknown) = AliasedDefinition : +# 535| mu535_3(unknown) = UnmodeledDefinition : +# 535| r535_4(glval) = VariableAddress[x] : +# 535| m535_5(int) = InitializeParameter[x] : &:r535_4 +# 535| r535_6(glval) = VariableAddress[y] : +# 535| m535_7(int) = InitializeParameter[y] : &:r535_6 +# 536| r536_1(glval) = VariableAddress[x] : +# 536| r536_2(int) = Load : &:r536_1, m535_5 +# 536| r536_3(glval) = VariableAddress[y] : +# 536| r536_4(int) = Load : &:r536_3, m535_7 +# 536| r536_5(bool) = CompareLT : r536_2, r536_4 +# 536| v536_6(void) = ConditionalBranch : r536_5 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 535| Block 1 +# 535| v535_8(void) = ReturnVoid : +# 535| v535_9(void) = UnmodeledUse : mu* +# 535| v535_10(void) = AliasedUse : ~m535_2 +# 535| v535_11(void) = ExitFunction : + +# 537| Block 2 +# 537| v537_1(void) = NoOp : +#-----| Goto -> Block 1 + +# 540| Block 3 +# 540| r540_1(glval) = VariableAddress[x] : +# 540| r540_2(int) = Load : &:r540_1, m535_5 +# 540| r540_3(glval) = VariableAddress[y] : +# 540| m540_4(int) = Store : &:r540_3, r540_2 +# 541| v541_1(void) = NoOp : +#-----| Goto -> Block 1 + +# 543| int EarlyReturnValue(int, int) +# 543| Block 0 +# 543| v543_1(void) = EnterFunction : +# 543| m543_2(unknown) = AliasedDefinition : +# 543| mu543_3(unknown) = UnmodeledDefinition : +# 543| r543_4(glval) = VariableAddress[x] : +# 543| m543_5(int) = InitializeParameter[x] : &:r543_4 +# 543| r543_6(glval) = VariableAddress[y] : +# 543| m543_7(int) = InitializeParameter[y] : &:r543_6 +# 544| r544_1(glval) = VariableAddress[x] : +# 544| r544_2(int) = Load : &:r544_1, m543_5 +# 544| r544_3(glval) = VariableAddress[y] : +# 544| r544_4(int) = Load : &:r544_3, m543_7 +# 544| r544_5(bool) = CompareLT : r544_2, r544_4 +# 544| v544_6(void) = ConditionalBranch : r544_5 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 543| Block 1 +# 543| m543_8(int) = Phi : from 2:m545_4, from 3:m548_7 +# 543| r543_9(glval) = VariableAddress[#return] : +# 543| v543_10(void) = ReturnValue : &:r543_9, m543_8 +# 543| v543_11(void) = UnmodeledUse : mu* +# 543| v543_12(void) = AliasedUse : ~m543_2 +# 543| v543_13(void) = ExitFunction : + +# 545| Block 2 +# 545| r545_1(glval) = VariableAddress[#return] : +# 545| r545_2(glval) = VariableAddress[x] : +# 545| r545_3(int) = Load : &:r545_2, m543_5 +# 545| m545_4(int) = Store : &:r545_1, r545_3 +#-----| Goto -> Block 1 + +# 548| Block 3 +# 548| r548_1(glval) = VariableAddress[#return] : +# 548| r548_2(glval) = VariableAddress[x] : +# 548| r548_3(int) = Load : &:r548_2, m543_5 +# 548| r548_4(glval) = VariableAddress[y] : +# 548| r548_5(int) = Load : &:r548_4, m543_7 +# 548| r548_6(int) = Add : r548_3, r548_5 +# 548| m548_7(int) = Store : &:r548_1, r548_6 +#-----| Goto -> Block 1 + +# 551| int CallViaFuncPtr(int(*)(int)) +# 551| Block 0 +# 551| v551_1(void) = EnterFunction : +# 551| m551_2(unknown) = AliasedDefinition : +# 551| mu551_3(unknown) = UnmodeledDefinition : +# 551| r551_4(glval<..(*)(..)>) = VariableAddress[pfn] : +# 551| m551_5(..(*)(..)) = InitializeParameter[pfn] : &:r551_4 +# 552| r552_1(glval) = VariableAddress[#return] : +# 552| r552_2(glval<..(*)(..)>) = VariableAddress[pfn] : +# 552| r552_3(..(*)(..)) = Load : &:r552_2, m551_5 +# 552| r552_4(int) = Constant[5] : +# 552| r552_5(int) = Call : func:r552_3, 0:r552_4 +# 552| m552_6(unknown) = ^CallSideEffect : ~m551_2 +# 552| m552_7(unknown) = Chi : total:m551_2, partial:m552_6 +# 552| m552_8(int) = Store : &:r552_1, r552_5 +# 551| r551_6(glval) = VariableAddress[#return] : +# 551| v551_7(void) = ReturnValue : &:r551_6, m552_8 +# 551| v551_8(void) = UnmodeledUse : mu* +# 551| v551_9(void) = AliasedUse : ~m552_7 +# 551| v551_10(void) = ExitFunction : + +# 560| int EnumSwitch(E) +# 560| Block 0 +# 560| v560_1(void) = EnterFunction : +# 560| m560_2(unknown) = AliasedDefinition : +# 560| mu560_3(unknown) = UnmodeledDefinition : +# 560| r560_4(glval) = VariableAddress[e] : +# 560| m560_5(E) = InitializeParameter[e] : &:r560_4 +# 561| r561_1(glval) = VariableAddress[e] : +# 561| r561_2(E) = Load : &:r561_1, m560_5 +# 561| r561_3(int) = Convert : r561_2 +# 561| v561_4(void) = Switch : r561_3 +#-----| Case[0] -> Block 4 +#-----| Case[1] -> Block 2 +#-----| Default -> Block 3 + +# 560| Block 1 +# 560| m560_6(int) = Phi : from 2:m565_3, from 3:m567_3, from 4:m563_3 +# 560| r560_7(glval) = VariableAddress[#return] : +# 560| v560_8(void) = ReturnValue : &:r560_7, m560_6 +# 560| v560_9(void) = UnmodeledUse : mu* +# 560| v560_10(void) = AliasedUse : ~m560_2 +# 560| v560_11(void) = ExitFunction : + +# 564| Block 2 +# 564| v564_1(void) = NoOp : +# 565| r565_1(glval) = VariableAddress[#return] : +# 565| r565_2(int) = Constant[1] : +# 565| m565_3(int) = Store : &:r565_1, r565_2 +#-----| Goto -> Block 1 + +# 566| Block 3 +# 566| v566_1(void) = NoOp : +# 567| r567_1(glval) = VariableAddress[#return] : +# 567| r567_2(int) = Constant[-1] : +# 567| m567_3(int) = Store : &:r567_1, r567_2 +#-----| Goto -> Block 1 + +# 562| Block 4 +# 562| v562_1(void) = NoOp : +# 563| r563_1(glval) = VariableAddress[#return] : +# 563| r563_2(int) = Constant[0] : +# 563| m563_3(int) = Store : &:r563_1, r563_2 +#-----| Goto -> Block 1 + +# 571| void InitArray() +# 571| Block 0 +# 571| v571_1(void) = EnterFunction : +# 571| m571_2(unknown) = AliasedDefinition : +# 571| mu571_3(unknown) = UnmodeledDefinition : +# 572| r572_1(glval) = VariableAddress[a_pad] : +# 572| r572_2(glval) = StringConstant[""] : +# 572| r572_3(char[32]) = Load : &:r572_2, ~m571_2 +# 572| m572_4(char[32]) = Store : &:r572_1, r572_3 +# 573| r573_1(glval) = VariableAddress[a_nopad] : +# 573| r573_2(glval) = StringConstant["foo"] : +# 573| r573_3(char[4]) = Load : &:r573_2, ~m571_2 +# 573| m573_4(char[4]) = Store : &:r573_1, r573_3 +# 574| r574_1(glval) = VariableAddress[a_infer] : +# 574| r574_2(glval) = StringConstant["blah"] : +# 574| r574_3(char[5]) = Load : &:r574_2, ~m571_2 +# 574| m574_4(char[5]) = Store : &:r574_1, r574_3 +# 575| r575_1(glval) = VariableAddress[b] : +# 575| m575_2(char[2]) = Uninitialized[b] : &:r575_1 +# 576| r576_1(glval) = VariableAddress[c] : +# 576| m576_2(char[2]) = Uninitialized[c] : &:r576_1 +# 576| r576_3(int) = Constant[0] : +# 576| r576_4(glval) = PointerAdd[1] : r576_1, r576_3 +# 576| r576_5(unknown[2]) = Constant[0] : +# 576| m576_6(unknown[2]) = Store : &:r576_4, r576_5 +# 577| r577_1(glval) = VariableAddress[d] : +# 577| m577_2(char[2]) = Uninitialized[d] : &:r577_1 +# 577| r577_3(int) = Constant[0] : +# 577| r577_4(glval) = PointerAdd[1] : r577_1, r577_3 +# 577| r577_5(char) = Constant[0] : +# 577| m577_6(char) = Store : &:r577_4, r577_5 +# 577| m577_7(char[2]) = Chi : total:m577_2, partial:m577_6 +# 577| r577_8(int) = Constant[1] : +# 577| r577_9(glval) = PointerAdd[1] : r577_1, r577_8 +# 577| r577_10(char) = Constant[0] : +# 577| m577_11(char) = Store : &:r577_9, r577_10 +# 577| m577_12(char[2]) = Chi : total:m577_7, partial:m577_11 +# 578| r578_1(glval) = VariableAddress[e] : +# 578| m578_2(char[2]) = Uninitialized[e] : &:r578_1 +# 578| r578_3(int) = Constant[0] : +# 578| r578_4(glval) = PointerAdd[1] : r578_1, r578_3 +# 578| r578_5(char) = Constant[0] : +# 578| m578_6(char) = Store : &:r578_4, r578_5 +# 578| m578_7(char[2]) = Chi : total:m578_2, partial:m578_6 +# 578| r578_8(int) = Constant[1] : +# 578| r578_9(glval) = PointerAdd[1] : r578_1, r578_8 +# 578| r578_10(char) = Constant[1] : +# 578| m578_11(char) = Store : &:r578_9, r578_10 +# 578| m578_12(char[2]) = Chi : total:m578_7, partial:m578_11 +# 579| r579_1(glval) = VariableAddress[f] : +# 579| m579_2(char[3]) = Uninitialized[f] : &:r579_1 +# 579| r579_3(int) = Constant[0] : +# 579| r579_4(glval) = PointerAdd[1] : r579_1, r579_3 +# 579| r579_5(char) = Constant[0] : +# 579| m579_6(char) = Store : &:r579_4, r579_5 +# 579| m579_7(char[3]) = Chi : total:m579_2, partial:m579_6 +# 579| r579_8(int) = Constant[1] : +# 579| r579_9(glval) = PointerAdd[1] : r579_1, r579_8 +# 579| r579_10(unknown[2]) = Constant[0] : +# 579| m579_11(unknown[2]) = Store : &:r579_9, r579_10 +# 579| m579_12(char[3]) = Chi : total:m579_7, partial:m579_11 +# 580| v580_1(void) = NoOp : +# 571| v571_4(void) = ReturnVoid : +# 571| v571_5(void) = UnmodeledUse : mu* +# 571| v571_6(void) = AliasedUse : ~m571_2 +# 571| v571_7(void) = ExitFunction : + +# 584| void VarArgs() +# 584| Block 0 +# 584| v584_1(void) = EnterFunction : +# 584| m584_2(unknown) = AliasedDefinition : +# 584| mu584_3(unknown) = UnmodeledDefinition : +# 585| r585_1(glval) = FunctionAddress[VarArgFunction] : +# 585| r585_2(glval) = StringConstant["%d %s"] : +# 585| r585_3(char *) = Convert : r585_2 +# 585| r585_4(int) = Constant[1] : +# 585| r585_5(glval) = StringConstant["string"] : +# 585| r585_6(char *) = Convert : r585_5 +# 585| v585_7(void) = Call : func:r585_1, 0:r585_3, 1:r585_4, 2:r585_6 +# 585| m585_8(unknown) = ^CallSideEffect : ~m584_2 +# 585| m585_9(unknown) = Chi : total:m584_2, partial:m585_8 +# 585| v585_10(void) = ^BufferReadSideEffect[0] : &:r585_3, ~m584_2 +# 585| v585_11(void) = ^BufferReadSideEffect[2] : &:r585_6, ~m584_2 +# 585| m585_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r585_3 +# 585| m585_13(unknown) = Chi : total:m585_9, partial:m585_12 +# 585| m585_14(unknown) = ^BufferMayWriteSideEffect[2] : &:r585_6 +# 585| m585_15(unknown) = Chi : total:m585_13, partial:m585_14 +# 586| v586_1(void) = NoOp : +# 584| v584_4(void) = ReturnVoid : +# 584| v584_5(void) = UnmodeledUse : mu* +# 584| v584_6(void) = AliasedUse : ~m585_15 +# 584| v584_7(void) = ExitFunction : + +# 590| void SetFuncPtr() +# 590| Block 0 +# 590| v590_1(void) = EnterFunction : +# 590| m590_2(unknown) = AliasedDefinition : +# 590| mu590_3(unknown) = UnmodeledDefinition : +# 591| r591_1(glval<..(*)(..)>) = VariableAddress[pfn] : +# 591| r591_2(..(*)(..)) = FunctionAddress[FuncPtrTarget] : +# 591| m591_3(..(*)(..)) = Store : &:r591_1, r591_2 +# 592| r592_1(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 592| r592_2(..(*)(..)) = CopyValue : r592_1 +# 592| r592_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 592| m592_4(..(*)(..)) = Store : &:r592_3, r592_2 +# 593| r593_1(..(*)(..)) = FunctionAddress[FuncPtrTarget] : +# 593| r593_2(..(*)(..)) = CopyValue : r593_1 +# 593| r593_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 593| m593_4(..(*)(..)) = Store : &:r593_3, r593_2 +# 594| r594_1(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 594| r594_2(..(*)(..)) = CopyValue : r594_1 +# 594| r594_3(..(*)(..)) = CopyValue : r594_2 +# 594| r594_4(..(*)(..)) = CopyValue : r594_3 +# 594| r594_5(..(*)(..)) = CopyValue : r594_4 +# 594| r594_6(glval<..(*)(..)>) = VariableAddress[pfn] : +# 594| m594_7(..(*)(..)) = Store : &:r594_6, r594_5 +# 595| v595_1(void) = NoOp : +# 590| v590_4(void) = ReturnVoid : +# 590| v590_5(void) = UnmodeledUse : mu* +# 590| v590_6(void) = AliasedUse : ~m590_2 +# 590| v590_7(void) = ExitFunction : + +# 615| void DeclareObject() +# 615| Block 0 +# 615| v615_1(void) = EnterFunction : +# 615| m615_2(unknown) = AliasedDefinition : +# 615| mu615_3(unknown) = UnmodeledDefinition : +# 616| r616_1(glval) = VariableAddress[s1] : +# 616| m616_2(String) = Uninitialized[s1] : &:r616_1 +# 616| r616_3(glval) = FunctionAddress[String] : +# 616| v616_4(void) = Call : func:r616_3, this:r616_1 +# 616| m616_5(unknown) = ^CallSideEffect : ~m615_2 +# 616| m616_6(unknown) = Chi : total:m615_2, partial:m616_5 +# 616| m616_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r616_1 +# 616| m616_8(String) = Chi : total:m616_2, partial:m616_7 +# 617| r617_1(glval) = VariableAddress[s2] : +# 617| m617_2(String) = Uninitialized[s2] : &:r617_1 +# 617| r617_3(glval) = FunctionAddress[String] : +# 617| r617_4(glval) = StringConstant["hello"] : +# 617| r617_5(char *) = Convert : r617_4 +# 617| v617_6(void) = Call : func:r617_3, this:r617_1, 0:r617_5 +# 617| m617_7(unknown) = ^CallSideEffect : ~m616_6 +# 617| m617_8(unknown) = Chi : total:m616_6, partial:m617_7 +# 617| m617_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r617_1 +# 617| m617_10(String) = Chi : total:m617_2, partial:m617_9 +# 617| v617_11(void) = ^BufferReadSideEffect[0] : &:r617_5, ~m615_2 +# 617| m617_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r617_5 +# 617| m617_13(unknown) = Chi : total:m617_8, partial:m617_12 +# 618| r618_1(glval) = VariableAddress[s3] : +# 618| r618_2(glval) = FunctionAddress[ReturnObject] : +# 618| r618_3(String) = Call : func:r618_2 +# 618| m618_4(unknown) = ^CallSideEffect : ~m617_13 +# 618| m618_5(unknown) = Chi : total:m617_13, partial:m618_4 +# 618| m618_6(String) = Store : &:r618_1, r618_3 +# 619| r619_1(glval) = VariableAddress[s4] : +# 619| m619_2(String) = Uninitialized[s4] : &:r619_1 +# 619| r619_3(glval) = FunctionAddress[String] : +# 619| r619_4(glval) = StringConstant["test"] : +# 619| r619_5(char *) = Convert : r619_4 +# 619| v619_6(void) = Call : func:r619_3, this:r619_1, 0:r619_5 +# 619| m619_7(unknown) = ^CallSideEffect : ~m618_5 +# 619| m619_8(unknown) = Chi : total:m618_5, partial:m619_7 +# 619| m619_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r619_1 +# 619| m619_10(String) = Chi : total:m619_2, partial:m619_9 +# 619| v619_11(void) = ^BufferReadSideEffect[0] : &:r619_5, ~m615_2 +# 619| m619_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r619_5 +# 619| m619_13(unknown) = Chi : total:m619_8, partial:m619_12 +# 620| v620_1(void) = NoOp : +# 615| v615_4(void) = ReturnVoid : +# 615| v615_5(void) = UnmodeledUse : mu* +# 615| v615_6(void) = AliasedUse : ~m619_13 +# 615| v615_7(void) = ExitFunction : + +# 622| void CallMethods(String&, String*, String) +# 622| Block 0 +# 622| v622_1(void) = EnterFunction : +# 622| m622_2(unknown) = AliasedDefinition : +# 622| mu622_3(unknown) = UnmodeledDefinition : +# 622| r622_4(glval) = VariableAddress[r] : +# 622| m622_5(String &) = InitializeParameter[r] : &:r622_4 +# 622| r622_6(String &) = Load : &:r622_4, m622_5 +# 622| m622_7(unknown) = InitializeIndirection[r] : &:r622_6 +# 622| m622_8(unknown) = Chi : total:m622_2, partial:m622_7 +# 622| r622_9(glval) = VariableAddress[p] : +# 622| m622_10(String *) = InitializeParameter[p] : &:r622_9 +# 622| r622_11(String *) = Load : &:r622_9, m622_10 +# 622| m622_12(unknown) = InitializeIndirection[p] : &:r622_11 +# 622| m622_13(unknown) = Chi : total:m622_8, partial:m622_12 +# 622| r622_14(glval) = VariableAddress[s] : +# 622| m622_15(String) = InitializeParameter[s] : &:r622_14 +# 623| r623_1(glval) = VariableAddress[r] : +# 623| r623_2(String &) = Load : &:r623_1, m622_5 +# 623| r623_3(glval) = CopyValue : r623_2 +# 623| r623_4(glval) = Convert : r623_3 +# 623| r623_5(glval) = FunctionAddress[c_str] : +# 623| r623_6(char *) = Call : func:r623_5, this:r623_4 +# 623| m623_7(unknown) = ^CallSideEffect : ~m622_13 +# 623| m623_8(unknown) = Chi : total:m622_13, partial:m623_7 +# 623| v623_9(void) = ^BufferReadSideEffect[-1] : &:r623_4, ~m623_8 +# 623| m623_10(String) = ^IndirectMayWriteSideEffect[-1] : &:r623_4 +# 623| m623_11(unknown) = Chi : total:m623_8, partial:m623_10 +# 624| r624_1(glval) = VariableAddress[p] : +# 624| r624_2(String *) = Load : &:r624_1, m622_10 +# 624| r624_3(String *) = Convert : r624_2 +# 624| r624_4(glval) = FunctionAddress[c_str] : +# 624| r624_5(char *) = Call : func:r624_4, this:r624_3 +# 624| m624_6(unknown) = ^CallSideEffect : ~m623_11 +# 624| m624_7(unknown) = Chi : total:m623_11, partial:m624_6 +# 624| v624_8(void) = ^BufferReadSideEffect[-1] : &:r624_3, ~m624_7 +# 624| m624_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r624_3 +# 624| m624_10(unknown) = Chi : total:m624_7, partial:m624_9 +# 625| r625_1(glval) = VariableAddress[s] : +# 625| r625_2(glval) = Convert : r625_1 +# 625| r625_3(glval) = FunctionAddress[c_str] : +# 625| r625_4(char *) = Call : func:r625_3, this:r625_2 +# 625| m625_5(unknown) = ^CallSideEffect : ~m624_10 +# 625| m625_6(unknown) = Chi : total:m624_10, partial:m625_5 +# 625| v625_7(void) = ^BufferReadSideEffect[-1] : &:r625_2, ~m622_15 +# 625| m625_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r625_2 +# 625| m625_9(String) = Chi : total:m622_15, partial:m625_8 +# 626| v626_1(void) = NoOp : +# 622| v622_16(void) = ReturnIndirection : &:r622_6, ~m625_6 +# 622| v622_17(void) = ReturnIndirection : &:r622_11, ~m625_6 +# 622| v622_18(void) = ReturnVoid : +# 622| v622_19(void) = UnmodeledUse : mu* +# 622| v622_20(void) = AliasedUse : ~m625_6 +# 622| v622_21(void) = ExitFunction : + +# 630| int C::StaticMemberFunction(int) +# 630| Block 0 +# 630| v630_1(void) = EnterFunction : +# 630| m630_2(unknown) = AliasedDefinition : +# 630| mu630_3(unknown) = UnmodeledDefinition : +# 630| r630_4(glval) = VariableAddress[x] : +# 630| m630_5(int) = InitializeParameter[x] : &:r630_4 +# 631| r631_1(glval) = VariableAddress[#return] : +# 631| r631_2(glval) = VariableAddress[x] : +# 631| r631_3(int) = Load : &:r631_2, m630_5 +# 631| m631_4(int) = Store : &:r631_1, r631_3 +# 630| r630_6(glval) = VariableAddress[#return] : +# 630| v630_7(void) = ReturnValue : &:r630_6, m631_4 +# 630| v630_8(void) = UnmodeledUse : mu* +# 630| v630_9(void) = AliasedUse : ~m630_2 +# 630| v630_10(void) = ExitFunction : + +# 634| int C::InstanceMemberFunction(int) +# 634| Block 0 +# 634| v634_1(void) = EnterFunction : +# 634| m634_2(unknown) = AliasedDefinition : +# 634| mu634_3(unknown) = UnmodeledDefinition : +# 634| r634_4(glval) = InitializeThis : +# 634| r634_5(glval) = VariableAddress[x] : +# 634| m634_6(int) = InitializeParameter[x] : &:r634_5 +# 635| r635_1(glval) = VariableAddress[#return] : +# 635| r635_2(glval) = VariableAddress[x] : +# 635| r635_3(int) = Load : &:r635_2, m634_6 +# 635| m635_4(int) = Store : &:r635_1, r635_3 +# 634| r634_7(glval) = VariableAddress[#return] : +# 634| v634_8(void) = ReturnValue : &:r634_7, m635_4 +# 634| v634_9(void) = UnmodeledUse : mu* +# 634| v634_10(void) = AliasedUse : ~m634_2 +# 634| v634_11(void) = ExitFunction : + +# 638| int C::VirtualMemberFunction(int) +# 638| Block 0 +# 638| v638_1(void) = EnterFunction : +# 638| m638_2(unknown) = AliasedDefinition : +# 638| mu638_3(unknown) = UnmodeledDefinition : +# 638| r638_4(glval) = InitializeThis : +# 638| r638_5(glval) = VariableAddress[x] : +# 638| m638_6(int) = InitializeParameter[x] : &:r638_5 +# 639| r639_1(glval) = VariableAddress[#return] : +# 639| r639_2(glval) = VariableAddress[x] : +# 639| r639_3(int) = Load : &:r639_2, m638_6 +# 639| m639_4(int) = Store : &:r639_1, r639_3 +# 638| r638_7(glval) = VariableAddress[#return] : +# 638| v638_8(void) = ReturnValue : &:r638_7, m639_4 +# 638| v638_9(void) = UnmodeledUse : mu* +# 638| v638_10(void) = AliasedUse : ~m638_2 +# 638| v638_11(void) = ExitFunction : + +# 642| void C::FieldAccess() +# 642| Block 0 +# 642| v642_1(void) = EnterFunction : +# 642| m642_2(unknown) = AliasedDefinition : +# 642| mu642_3(unknown) = UnmodeledDefinition : +# 642| r642_4(glval) = InitializeThis : +# 643| r643_1(int) = Constant[0] : +# 643| r643_2(C *) = CopyValue : r642_4 +# 643| r643_3(glval) = FieldAddress[m_a] : r643_2 +# 643| m643_4(int) = Store : &:r643_3, r643_1 +# 643| m643_5(unknown) = Chi : total:m642_2, partial:m643_4 +# 644| r644_1(int) = Constant[1] : +# 644| r644_2(C *) = CopyValue : r642_4 +# 644| r644_3(glval) = CopyValue : r644_2 +# 644| r644_4(glval) = FieldAddress[m_a] : r644_3 +# 644| m644_5(int) = Store : &:r644_4, r644_1 +# 644| m644_6(unknown) = Chi : total:m643_5, partial:m644_5 +# 645| r645_1(int) = Constant[2] : +#-----| r0_1(C *) = CopyValue : r642_4 +# 645| r645_2(glval) = FieldAddress[m_a] : r0_1 +# 645| m645_3(int) = Store : &:r645_2, r645_1 +# 645| m645_4(unknown) = Chi : total:m644_6, partial:m645_3 +# 646| r646_1(glval) = VariableAddress[x] : +# 646| m646_2(int) = Uninitialized[x] : &:r646_1 +# 647| r647_1(C *) = CopyValue : r642_4 +# 647| r647_2(glval) = FieldAddress[m_a] : r647_1 +# 647| r647_3(int) = Load : &:r647_2, ~m645_4 +# 647| r647_4(glval) = VariableAddress[x] : +# 647| m647_5(int) = Store : &:r647_4, r647_3 +# 648| r648_1(C *) = CopyValue : r642_4 +# 648| r648_2(glval) = CopyValue : r648_1 +# 648| r648_3(glval) = FieldAddress[m_a] : r648_2 +# 648| r648_4(int) = Load : &:r648_3, ~m645_4 +# 648| r648_5(glval) = VariableAddress[x] : +# 648| m648_6(int) = Store : &:r648_5, r648_4 +#-----| r0_2(C *) = CopyValue : r642_4 +# 649| r649_1(glval) = FieldAddress[m_a] : r0_2 +# 649| r649_2(int) = Load : &:r649_1, ~m645_4 +# 649| r649_3(glval) = VariableAddress[x] : +# 649| m649_4(int) = Store : &:r649_3, r649_2 +# 650| v650_1(void) = NoOp : +# 642| v642_5(void) = ReturnVoid : +# 642| v642_6(void) = UnmodeledUse : mu* +# 642| v642_7(void) = AliasedUse : ~m645_4 +# 642| v642_8(void) = ExitFunction : + +# 652| void C::MethodCalls() +# 652| Block 0 +# 652| v652_1(void) = EnterFunction : +# 652| m652_2(unknown) = AliasedDefinition : +# 652| mu652_3(unknown) = UnmodeledDefinition : +# 652| r652_4(glval) = InitializeThis : +# 653| r653_1(C *) = CopyValue : r652_4 +# 653| r653_2(glval) = FunctionAddress[InstanceMemberFunction] : +# 653| r653_3(int) = Constant[0] : +# 653| r653_4(int) = Call : func:r653_2, this:r653_1, 0:r653_3 +# 653| m653_5(unknown) = ^CallSideEffect : ~m652_2 +# 653| m653_6(unknown) = Chi : total:m652_2, partial:m653_5 +# 653| v653_7(void) = ^BufferReadSideEffect[-1] : &:r653_1, ~m653_6 +# 653| m653_8(C) = ^IndirectMayWriteSideEffect[-1] : &:r653_1 +# 653| m653_9(unknown) = Chi : total:m653_6, partial:m653_8 +# 654| r654_1(C *) = CopyValue : r652_4 +# 654| r654_2(glval) = CopyValue : r654_1 +# 654| r654_3(glval) = FunctionAddress[InstanceMemberFunction] : +# 654| r654_4(int) = Constant[1] : +# 654| r654_5(int) = Call : func:r654_3, this:r654_2, 0:r654_4 +# 654| m654_6(unknown) = ^CallSideEffect : ~m653_9 +# 654| m654_7(unknown) = Chi : total:m653_9, partial:m654_6 +# 654| v654_8(void) = ^BufferReadSideEffect[-1] : &:r654_2, ~m654_7 +# 654| m654_9(C) = ^IndirectMayWriteSideEffect[-1] : &:r654_2 +# 654| m654_10(unknown) = Chi : total:m654_7, partial:m654_9 +#-----| r0_1(C *) = CopyValue : r652_4 +# 655| r655_1(glval) = FunctionAddress[InstanceMemberFunction] : +# 655| r655_2(int) = Constant[2] : +# 655| r655_3(int) = Call : func:r655_1, this:r0_1, 0:r655_2 +# 655| m655_4(unknown) = ^CallSideEffect : ~m654_10 +# 655| m655_5(unknown) = Chi : total:m654_10, partial:m655_4 +#-----| v0_2(void) = ^BufferReadSideEffect[-1] : &:r0_1, ~m655_5 +#-----| m0_3(C) = ^IndirectMayWriteSideEffect[-1] : &:r0_1 +#-----| m0_4(unknown) = Chi : total:m655_5, partial:m0_3 +# 656| v656_1(void) = NoOp : +# 652| v652_5(void) = ReturnVoid : +# 652| v652_6(void) = UnmodeledUse : mu* +# 652| v652_7(void) = AliasedUse : ~m0_4 +# 652| v652_8(void) = ExitFunction : + +# 658| void C::C() +# 658| Block 0 +# 658| v658_1(void) = EnterFunction : +# 658| m658_2(unknown) = AliasedDefinition : +# 658| mu658_3(unknown) = UnmodeledDefinition : +# 658| r658_4(glval) = InitializeThis : +# 659| r659_1(glval) = FieldAddress[m_a] : r658_4 +# 659| r659_2(int) = Constant[1] : +# 659| m659_3(int) = Store : &:r659_1, r659_2 +# 659| m659_4(unknown) = Chi : total:m658_2, partial:m659_3 +# 663| r663_1(glval) = FieldAddress[m_b] : r658_4 +# 663| r663_2(glval) = FunctionAddress[String] : +# 663| v663_3(void) = Call : func:r663_2, this:r663_1 +# 663| m663_4(unknown) = ^CallSideEffect : ~m659_4 +# 663| m663_5(unknown) = Chi : total:m659_4, partial:m663_4 +# 663| m663_6(String) = ^IndirectMayWriteSideEffect[-1] : &:r663_1 +# 663| m663_7(unknown) = Chi : total:m663_5, partial:m663_6 +# 660| r660_1(glval) = FieldAddress[m_c] : r658_4 +# 660| r660_2(char) = Constant[3] : +# 660| m660_3(char) = Store : &:r660_1, r660_2 +# 660| m660_4(unknown) = Chi : total:m663_7, partial:m660_3 +# 661| r661_1(glval) = FieldAddress[m_e] : r658_4 +# 661| r661_2(void *) = Constant[0] : +# 661| m661_3(void *) = Store : &:r661_1, r661_2 +# 661| m661_4(unknown) = Chi : total:m660_4, partial:m661_3 +# 662| r662_1(glval) = FieldAddress[m_f] : r658_4 +# 662| r662_2(glval) = FunctionAddress[String] : +# 662| r662_3(glval) = StringConstant["test"] : +# 662| r662_4(char *) = Convert : r662_3 +# 662| v662_5(void) = Call : func:r662_2, this:r662_1, 0:r662_4 +# 662| m662_6(unknown) = ^CallSideEffect : ~m661_4 +# 662| m662_7(unknown) = Chi : total:m661_4, partial:m662_6 +# 662| m662_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r662_1 +# 662| m662_9(unknown) = Chi : total:m662_7, partial:m662_8 +# 662| v662_10(void) = ^BufferReadSideEffect[0] : &:r662_4, ~m658_2 +# 662| m662_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r662_4 +# 662| m662_12(unknown) = Chi : total:m662_9, partial:m662_11 +# 664| v664_1(void) = NoOp : +# 658| v658_5(void) = ReturnVoid : +# 658| v658_6(void) = UnmodeledUse : mu* +# 658| v658_7(void) = AliasedUse : ~m662_12 +# 658| v658_8(void) = ExitFunction : + +# 675| int DerefReference(int&) +# 675| Block 0 +# 675| v675_1(void) = EnterFunction : +# 675| m675_2(unknown) = AliasedDefinition : +# 675| mu675_3(unknown) = UnmodeledDefinition : +# 675| r675_4(glval) = VariableAddress[r] : +# 675| m675_5(int &) = InitializeParameter[r] : &:r675_4 +# 675| r675_6(int &) = Load : &:r675_4, m675_5 +# 675| m675_7(unknown) = InitializeIndirection[r] : &:r675_6 +# 675| m675_8(unknown) = Chi : total:m675_2, partial:m675_7 +# 676| r676_1(glval) = VariableAddress[#return] : +# 676| r676_2(glval) = VariableAddress[r] : +# 676| r676_3(int &) = Load : &:r676_2, m675_5 +# 676| r676_4(int) = Load : &:r676_3, ~m675_8 +# 676| m676_5(int) = Store : &:r676_1, r676_4 +# 675| v675_9(void) = ReturnIndirection : &:r675_6, ~m675_8 +# 675| r675_10(glval) = VariableAddress[#return] : +# 675| v675_11(void) = ReturnValue : &:r675_10, m676_5 +# 675| v675_12(void) = UnmodeledUse : mu* +# 675| v675_13(void) = AliasedUse : ~m675_8 +# 675| v675_14(void) = ExitFunction : + +# 679| int& TakeReference() +# 679| Block 0 +# 679| v679_1(void) = EnterFunction : +# 679| m679_2(unknown) = AliasedDefinition : +# 679| mu679_3(unknown) = UnmodeledDefinition : +# 680| r680_1(glval) = VariableAddress[#return] : +# 680| r680_2(glval) = VariableAddress[g] : +# 680| r680_3(int &) = CopyValue : r680_2 +# 680| m680_4(int &) = Store : &:r680_1, r680_3 +# 679| r679_4(glval) = VariableAddress[#return] : +# 679| v679_5(void) = ReturnValue : &:r679_4, m680_4 +# 679| v679_6(void) = UnmodeledUse : mu* +# 679| v679_7(void) = AliasedUse : ~m679_2 +# 679| v679_8(void) = ExitFunction : + +# 685| void InitReference(int) +# 685| Block 0 +# 685| v685_1(void) = EnterFunction : +# 685| m685_2(unknown) = AliasedDefinition : +# 685| mu685_3(unknown) = UnmodeledDefinition : +# 685| r685_4(glval) = VariableAddress[x] : +# 685| m685_5(int) = InitializeParameter[x] : &:r685_4 +# 686| r686_1(glval) = VariableAddress[r] : +# 686| r686_2(glval) = VariableAddress[x] : +# 686| r686_3(int &) = CopyValue : r686_2 +# 686| m686_4(int &) = Store : &:r686_1, r686_3 +# 687| r687_1(glval) = VariableAddress[r2] : +# 687| r687_2(glval) = VariableAddress[r] : +# 687| r687_3(int &) = Load : &:r687_2, m686_4 +# 687| r687_4(glval) = CopyValue : r687_3 +# 687| r687_5(int &) = CopyValue : r687_4 +# 687| m687_6(int &) = Store : &:r687_1, r687_5 +# 688| r688_1(glval) = VariableAddress[r3] : +# 688| r688_2(glval) = FunctionAddress[ReturnReference] : +# 688| r688_3(String &) = Call : func:r688_2 +# 688| m688_4(unknown) = ^CallSideEffect : ~m685_2 +# 688| m688_5(unknown) = Chi : total:m685_2, partial:m688_4 +# 688| r688_6(glval) = CopyValue : r688_3 +# 688| r688_7(glval) = Convert : r688_6 +# 688| r688_8(String &) = CopyValue : r688_7 +# 688| m688_9(String &) = Store : &:r688_1, r688_8 +# 689| v689_1(void) = NoOp : +# 685| v685_6(void) = ReturnVoid : +# 685| v685_7(void) = UnmodeledUse : mu* +# 685| v685_8(void) = AliasedUse : ~m688_5 +# 685| v685_9(void) = ExitFunction : + +# 691| void ArrayReferences() +# 691| Block 0 +# 691| v691_1(void) = EnterFunction : +# 691| m691_2(unknown) = AliasedDefinition : +# 691| mu691_3(unknown) = UnmodeledDefinition : +# 692| r692_1(glval) = VariableAddress[a] : +# 692| m692_2(int[10]) = Uninitialized[a] : &:r692_1 +# 693| r693_1(glval) = VariableAddress[ra] : +# 693| r693_2(glval) = VariableAddress[a] : +# 693| r693_3(int(&)[10]) = CopyValue : r693_2 +# 693| m693_4(int(&)[10]) = Store : &:r693_1, r693_3 +# 694| r694_1(glval) = VariableAddress[x] : +# 694| r694_2(glval) = VariableAddress[ra] : +# 694| r694_3(int(&)[10]) = Load : &:r694_2, m693_4 +# 694| r694_4(glval) = CopyValue : r694_3 +# 694| r694_5(int *) = Convert : r694_4 +# 694| r694_6(int) = Constant[5] : +# 694| r694_7(glval) = PointerAdd[4] : r694_5, r694_6 +# 694| r694_8(int) = Load : &:r694_7, ~m692_2 +# 694| m694_9(int) = Store : &:r694_1, r694_8 +# 695| v695_1(void) = NoOp : +# 691| v691_4(void) = ReturnVoid : +# 691| v691_5(void) = UnmodeledUse : mu* +# 691| v691_6(void) = AliasedUse : ~m691_2 +# 691| v691_7(void) = ExitFunction : + +# 697| void FunctionReferences() +# 697| Block 0 +# 697| v697_1(void) = EnterFunction : +# 697| m697_2(unknown) = AliasedDefinition : +# 697| mu697_3(unknown) = UnmodeledDefinition : +# 698| r698_1(glval<..(&)(..)>) = VariableAddress[rfn] : +# 698| r698_2(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 698| r698_3(..(&)(..)) = CopyValue : r698_2 +# 698| m698_4(..(&)(..)) = Store : &:r698_1, r698_3 +# 699| r699_1(glval<..(*)(..)>) = VariableAddress[pfn] : +# 699| r699_2(glval<..(&)(..)>) = VariableAddress[rfn] : +# 699| r699_3(..(&)(..)) = Load : &:r699_2, m698_4 +# 699| r699_4(..(*)(..)) = CopyValue : r699_3 +# 699| m699_5(..(*)(..)) = Store : &:r699_1, r699_4 +# 700| r700_1(glval<..(&)(..)>) = VariableAddress[rfn] : +# 700| r700_2(..(&)(..)) = Load : &:r700_1, m698_4 +# 700| r700_3(..(*)(..)) = CopyValue : r700_2 +# 700| r700_4(int) = Constant[5] : +# 700| r700_5(int) = Call : func:r700_3, 0:r700_4 +# 700| m700_6(unknown) = ^CallSideEffect : ~m697_2 +# 700| m700_7(unknown) = Chi : total:m697_2, partial:m700_6 +# 701| v701_1(void) = NoOp : +# 697| v697_4(void) = ReturnVoid : +# 697| v697_5(void) = UnmodeledUse : mu* +# 697| v697_6(void) = AliasedUse : ~m700_7 +# 697| v697_7(void) = ExitFunction : + +# 704| int min(int, int) +# 704| Block 0 +# 704| v704_1(void) = EnterFunction : +# 704| m704_2(unknown) = AliasedDefinition : +# 704| mu704_3(unknown) = UnmodeledDefinition : +# 704| r704_4(glval) = VariableAddress[x] : +# 704| m704_5(int) = InitializeParameter[x] : &:r704_4 +# 704| r704_6(glval) = VariableAddress[y] : +# 704| m704_7(int) = InitializeParameter[y] : &:r704_6 +# 705| r705_1(glval) = VariableAddress[#return] : +# 705| r705_2(glval) = VariableAddress[x] : +# 705| r705_3(int) = Load : &:r705_2, m704_5 +# 705| r705_4(glval) = VariableAddress[y] : +# 705| r705_5(int) = Load : &:r705_4, m704_7 +# 705| r705_6(bool) = CompareLT : r705_3, r705_5 +# 705| v705_7(void) = ConditionalBranch : r705_6 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 705| Block 1 +# 705| r705_8(glval) = VariableAddress[x] : +# 705| r705_9(int) = Load : &:r705_8, m704_5 +# 705| r705_10(glval) = VariableAddress[#temp705:10] : +# 705| m705_11(int) = Store : &:r705_10, r705_9 +#-----| Goto -> Block 3 + +# 705| Block 2 +# 705| r705_12(glval) = VariableAddress[y] : +# 705| r705_13(int) = Load : &:r705_12, m704_7 +# 705| r705_14(glval) = VariableAddress[#temp705:10] : +# 705| m705_15(int) = Store : &:r705_14, r705_13 +#-----| Goto -> Block 3 + +# 705| Block 3 +# 705| m705_16(int) = Phi : from 1:m705_11, from 2:m705_15 +# 705| r705_17(glval) = VariableAddress[#temp705:10] : +# 705| r705_18(int) = Load : &:r705_17, m705_16 +# 705| m705_19(int) = Store : &:r705_1, r705_18 +# 704| r704_8(glval) = VariableAddress[#return] : +# 704| v704_9(void) = ReturnValue : &:r704_8, m705_19 +# 704| v704_10(void) = UnmodeledUse : mu* +# 704| v704_11(void) = AliasedUse : ~m704_2 +# 704| v704_12(void) = ExitFunction : + +# 708| int CallMin(int, int) +# 708| Block 0 +# 708| v708_1(void) = EnterFunction : +# 708| m708_2(unknown) = AliasedDefinition : +# 708| mu708_3(unknown) = UnmodeledDefinition : +# 708| r708_4(glval) = VariableAddress[x] : +# 708| m708_5(int) = InitializeParameter[x] : &:r708_4 +# 708| r708_6(glval) = VariableAddress[y] : +# 708| m708_7(int) = InitializeParameter[y] : &:r708_6 +# 709| r709_1(glval) = VariableAddress[#return] : +# 709| r709_2(glval) = FunctionAddress[min] : +# 709| r709_3(glval) = VariableAddress[x] : +# 709| r709_4(int) = Load : &:r709_3, m708_5 +# 709| r709_5(glval) = VariableAddress[y] : +# 709| r709_6(int) = Load : &:r709_5, m708_7 +# 709| r709_7(int) = Call : func:r709_2, 0:r709_4, 1:r709_6 +# 709| m709_8(unknown) = ^CallSideEffect : ~m708_2 +# 709| m709_9(unknown) = Chi : total:m708_2, partial:m709_8 +# 709| m709_10(int) = Store : &:r709_1, r709_7 +# 708| r708_8(glval) = VariableAddress[#return] : +# 708| v708_9(void) = ReturnValue : &:r708_8, m709_10 +# 708| v708_10(void) = UnmodeledUse : mu* +# 708| v708_11(void) = AliasedUse : ~m709_9 +# 708| v708_12(void) = ExitFunction : + +# 715| long Outer::Func(void*, char) +# 715| Block 0 +# 715| v715_1(void) = EnterFunction : +# 715| m715_2(unknown) = AliasedDefinition : +# 715| mu715_3(unknown) = UnmodeledDefinition : +# 715| r715_4(glval) = VariableAddress[x] : +# 715| m715_5(void *) = InitializeParameter[x] : &:r715_4 +# 715| r715_6(void *) = Load : &:r715_4, m715_5 +# 715| m715_7(unknown) = InitializeIndirection[x] : &:r715_6 +# 715| m715_8(unknown) = Chi : total:m715_2, partial:m715_7 +# 715| r715_9(glval) = VariableAddress[y] : +# 715| m715_10(char) = InitializeParameter[y] : &:r715_9 +# 716| r716_1(glval) = VariableAddress[#return] : +# 716| r716_2(long) = Constant[0] : +# 716| m716_3(long) = Store : &:r716_1, r716_2 +# 715| v715_11(void) = ReturnIndirection : &:r715_6, ~m715_8 +# 715| r715_12(glval) = VariableAddress[#return] : +# 715| v715_13(void) = ReturnValue : &:r715_12, m716_3 +# 715| v715_14(void) = UnmodeledUse : mu* +# 715| v715_15(void) = AliasedUse : ~m715_8 +# 715| v715_16(void) = ExitFunction : + +# 720| double CallNestedTemplateFunc() +# 720| Block 0 +# 720| v720_1(void) = EnterFunction : +# 720| m720_2(unknown) = AliasedDefinition : +# 720| mu720_3(unknown) = UnmodeledDefinition : +# 721| r721_1(glval) = VariableAddress[#return] : +# 721| r721_2(glval) = FunctionAddress[Func] : +# 721| r721_3(void *) = Constant[0] : +# 721| r721_4(char) = Constant[111] : +# 721| r721_5(long) = Call : func:r721_2, 0:r721_3, 1:r721_4 +# 721| m721_6(unknown) = ^CallSideEffect : ~m720_2 +# 721| m721_7(unknown) = Chi : total:m720_2, partial:m721_6 +# 721| v721_8(void) = ^BufferReadSideEffect[0] : &:r721_3, ~m721_7 +# 721| m721_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r721_3 +# 721| m721_10(unknown) = Chi : total:m721_7, partial:m721_9 +# 721| r721_11(double) = Convert : r721_5 +# 721| m721_12(double) = Store : &:r721_1, r721_11 +# 720| r720_4(glval) = VariableAddress[#return] : +# 720| v720_5(void) = ReturnValue : &:r720_4, m721_12 +# 720| v720_6(void) = UnmodeledUse : mu* +# 720| v720_7(void) = AliasedUse : ~m721_10 +# 720| v720_8(void) = ExitFunction : + +# 724| void TryCatch(bool) +# 724| Block 0 +# 724| v724_1(void) = EnterFunction : +# 724| m724_2(unknown) = AliasedDefinition : +# 724| mu724_3(unknown) = UnmodeledDefinition : +# 724| r724_4(glval) = VariableAddress[b] : +# 724| m724_5(bool) = InitializeParameter[b] : &:r724_4 +# 726| r726_1(glval) = VariableAddress[x] : +# 726| r726_2(int) = Constant[5] : +# 726| m726_3(int) = Store : &:r726_1, r726_2 +# 727| r727_1(glval) = VariableAddress[b] : +# 727| r727_2(bool) = Load : &:r727_1, m724_5 +# 727| v727_3(void) = ConditionalBranch : r727_2 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 724| Block 1 +# 724| m724_6(unknown) = Phi : from 2:~m724_10, from 11:~m743_1 +# 724| v724_7(void) = UnmodeledUse : mu* +# 724| v724_8(void) = AliasedUse : ~m724_6 +# 724| v724_9(void) = ExitFunction : + +# 724| Block 2 +# 724| m724_10(unknown) = Phi : from 7:~m736_13, from 10:~m724_2 +# 724| v724_11(void) = Unwind : +#-----| Goto -> Block 1 + +# 728| Block 3 +# 728| r728_1(glval) = VariableAddress[#throw728:7] : +# 728| r728_2(glval) = StringConstant["string literal"] : +# 728| r728_3(char *) = Convert : r728_2 +# 728| m728_4(char *) = Store : &:r728_1, r728_3 +# 728| v728_5(void) = ThrowValue : &:r728_1, m728_4 +#-----| Exception -> Block 6 + +# 730| Block 4 +# 730| r730_1(glval) = VariableAddress[x] : +# 730| r730_2(int) = Load : &:r730_1, m726_3 +# 730| r730_3(int) = Constant[2] : +# 730| r730_4(bool) = CompareLT : r730_2, r730_3 +# 730| v730_5(void) = ConditionalBranch : r730_4 +#-----| False -> Block 5 +#-----| True -> Block 12 + +# 733| Block 5 +# 733| r733_1(int) = Constant[7] : +# 733| r733_2(glval) = VariableAddress[x] : +# 733| m733_3(int) = Store : &:r733_2, r733_1 +#-----| Goto -> Block 11 + +# 735| Block 6 +# 735| v735_1(void) = CatchByType[const char *] : +#-----| Exception -> Block 8 +#-----| Goto -> Block 7 + +# 735| Block 7 +# 735| r735_2(glval) = VariableAddress[s] : +# 735| m735_3(char *) = InitializeParameter[s] : &:r735_2 +# 735| r735_4(char *) = Load : &:r735_2, m735_3 +# 735| m735_5(unknown) = InitializeIndirection[s] : &:r735_4 +# 735| m735_6(unknown) = Chi : total:m724_2, partial:m735_5 +# 736| r736_1(glval) = VariableAddress[#throw736:5] : +# 736| m736_2(String) = Uninitialized[#throw736:5] : &:r736_1 +# 736| r736_3(glval) = FunctionAddress[String] : +# 736| r736_4(glval) = VariableAddress[s] : +# 736| r736_5(char *) = Load : &:r736_4, m735_3 +# 736| v736_6(void) = Call : func:r736_3, this:r736_1, 0:r736_5 +# 736| m736_7(unknown) = ^CallSideEffect : ~m735_6 +# 736| m736_8(unknown) = Chi : total:m735_6, partial:m736_7 +# 736| m736_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r736_1 +# 736| m736_10(String) = Chi : total:m736_2, partial:m736_9 +# 736| v736_11(void) = ^BufferReadSideEffect[0] : &:r736_5, ~m736_8 +# 736| m736_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r736_5 +# 736| m736_13(unknown) = Chi : total:m736_8, partial:m736_12 +# 736| v736_14(void) = ThrowValue : &:r736_1, ~m736_10 +#-----| Exception -> Block 2 + +# 738| Block 8 +# 738| v738_1(void) = CatchByType[const String &] : +#-----| Exception -> Block 10 +#-----| Goto -> Block 9 + +# 738| Block 9 +# 738| r738_2(glval) = VariableAddress[e] : +# 738| m738_3(String &) = InitializeParameter[e] : &:r738_2 +# 738| r738_4(String &) = Load : &:r738_2, m738_3 +# 738| m738_5(unknown) = InitializeIndirection[e] : &:r738_4 +# 738| m738_6(unknown) = Chi : total:m724_2, partial:m738_5 +# 738| v738_7(void) = NoOp : +#-----| Goto -> Block 11 + +# 740| Block 10 +# 740| v740_1(void) = CatchAny : +# 741| v741_1(void) = ReThrow : +#-----| Exception -> Block 2 + +# 743| Block 11 +# 743| m743_1(unknown) = Phi : from 5:~m724_2, from 9:~m738_6 +# 743| v743_2(void) = NoOp : +# 724| v724_12(void) = ReturnVoid : +#-----| Goto -> Block 1 + +# 724| Block 12 +# 724| v724_13(void) = Unreached : + +# 745| Base& Base::operator=(Base const&) +# 745| Block 0 +# 745| v745_1(void) = EnterFunction : +# 745| m745_2(unknown) = AliasedDefinition : +# 745| mu745_3(unknown) = UnmodeledDefinition : +# 745| r745_4(glval) = InitializeThis : +#-----| r0_1(glval) = VariableAddress[p#0] : +#-----| m0_2(Base &) = InitializeParameter[p#0] : &:r0_1 +#-----| r0_3(Base &) = Load : &:r0_1, m0_2 +#-----| m0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 +#-----| m0_5(unknown) = Chi : total:m745_2, partial:m0_4 +#-----| r0_6(Base *) = CopyValue : r745_4 +#-----| r0_7(glval) = FieldAddress[base_s] : r0_6 +#-----| r0_8(String *) = CopyValue : r0_7 +# 745| r745_5(glval) = FunctionAddress[operator=] : +#-----| r0_9(glval) = VariableAddress[p#0] : +#-----| r0_10(Base &) = Load : &:r0_9, m0_2 +#-----| r0_11(glval) = CopyValue : r0_10 +#-----| r0_12(glval) = FieldAddress[base_s] : r0_11 +#-----| r0_13(String &) = CopyValue : r0_12 +# 745| r745_6(String &) = Call : func:r745_5, this:r0_8, 0:r0_13 +# 745| m745_7(unknown) = ^CallSideEffect : ~m0_5 +# 745| m745_8(unknown) = Chi : total:m0_5, partial:m745_7 +#-----| v0_14(void) = ^BufferReadSideEffect[-1] : &:r0_8, ~m745_8 +#-----| v0_15(void) = ^BufferReadSideEffect[0] : &:r0_13, ~m745_8 +#-----| m0_16(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 +#-----| m0_17(unknown) = Chi : total:m745_8, partial:m0_16 +#-----| m0_18(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_13 +#-----| m0_19(unknown) = Chi : total:m0_17, partial:m0_18 +#-----| r0_20(glval) = CopyValue : r745_6 +#-----| r0_21(glval) = VariableAddress[#return] : +#-----| r0_22(Base *) = CopyValue : r745_4 +#-----| r0_23(glval) = CopyValue : r0_22 +#-----| r0_24(Base &) = CopyValue : r0_23 +#-----| m0_25(Base &) = Store : &:r0_21, r0_24 +#-----| v0_26(void) = ReturnIndirection : &:r0_3, ~m0_19 +# 745| r745_9(glval) = VariableAddress[#return] : +# 745| v745_10(void) = ReturnValue : &:r745_9, m0_25 +# 745| v745_11(void) = UnmodeledUse : mu* +# 745| v745_12(void) = AliasedUse : ~m0_19 +# 745| v745_13(void) = ExitFunction : + +# 745| void Base::Base(Base const&) +# 745| Block 0 +# 745| v745_1(void) = EnterFunction : +# 745| m745_2(unknown) = AliasedDefinition : +# 745| mu745_3(unknown) = UnmodeledDefinition : +# 745| r745_4(glval) = InitializeThis : +#-----| r0_1(glval) = VariableAddress[p#0] : +#-----| m0_2(Base &) = InitializeParameter[p#0] : &:r0_1 +#-----| r0_3(Base &) = Load : &:r0_1, m0_2 +#-----| m0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 +#-----| m0_5(unknown) = Chi : total:m745_2, partial:m0_4 +# 745| r745_5(glval) = FieldAddress[base_s] : r745_4 +# 745| r745_6(glval) = FunctionAddress[String] : +# 745| v745_7(void) = Call : func:r745_6, this:r745_5 +# 745| m745_8(unknown) = ^CallSideEffect : ~m0_5 +# 745| m745_9(unknown) = Chi : total:m0_5, partial:m745_8 +# 745| m745_10(String) = ^IndirectMayWriteSideEffect[-1] : &:r745_5 +# 745| m745_11(unknown) = Chi : total:m745_9, partial:m745_10 +# 745| v745_12(void) = NoOp : +#-----| v0_6(void) = ReturnIndirection : &:r0_3, ~m745_11 +# 745| v745_13(void) = ReturnVoid : +# 745| v745_14(void) = UnmodeledUse : mu* +# 745| v745_15(void) = AliasedUse : ~m745_11 +# 745| v745_16(void) = ExitFunction : + +# 748| void Base::Base() +# 748| Block 0 +# 748| v748_1(void) = EnterFunction : +# 748| m748_2(unknown) = AliasedDefinition : +# 748| mu748_3(unknown) = UnmodeledDefinition : +# 748| r748_4(glval) = InitializeThis : +# 748| r748_5(glval) = FieldAddress[base_s] : r748_4 +# 748| r748_6(glval) = FunctionAddress[String] : +# 748| v748_7(void) = Call : func:r748_6, this:r748_5 +# 748| m748_8(unknown) = ^CallSideEffect : ~m748_2 +# 748| m748_9(unknown) = Chi : total:m748_2, partial:m748_8 +# 748| m748_10(String) = ^IndirectMayWriteSideEffect[-1] : &:r748_5 +# 748| m748_11(unknown) = Chi : total:m748_9, partial:m748_10 +# 749| v749_1(void) = NoOp : +# 748| v748_12(void) = ReturnVoid : +# 748| v748_13(void) = UnmodeledUse : mu* +# 748| v748_14(void) = AliasedUse : ~m748_11 +# 748| v748_15(void) = ExitFunction : + +# 750| void Base::~Base() +# 750| Block 0 +# 750| v750_1(void) = EnterFunction : +# 750| m750_2(unknown) = AliasedDefinition : +# 750| mu750_3(unknown) = UnmodeledDefinition : +# 750| r750_4(glval) = InitializeThis : +# 751| v751_1(void) = NoOp : +# 751| r751_2(glval) = FieldAddress[base_s] : r750_4 +# 751| r751_3(glval) = FunctionAddress[~String] : +# 751| v751_4(void) = Call : func:r751_3, this:r751_2 +# 751| m751_5(unknown) = ^CallSideEffect : ~m750_2 +# 751| m751_6(unknown) = Chi : total:m750_2, partial:m751_5 +# 750| v750_5(void) = ReturnVoid : +# 750| v750_6(void) = UnmodeledUse : mu* +# 750| v750_7(void) = AliasedUse : ~m751_6 +# 750| v750_8(void) = ExitFunction : + +# 754| Middle& Middle::operator=(Middle const&) +# 754| Block 0 +# 754| v754_1(void) = EnterFunction : +# 754| m754_2(unknown) = AliasedDefinition : +# 754| mu754_3(unknown) = UnmodeledDefinition : +# 754| r754_4(glval) = InitializeThis : +#-----| r0_1(glval) = VariableAddress[p#0] : +#-----| m0_2(Middle &) = InitializeParameter[p#0] : &:r0_1 +#-----| r0_3(Middle &) = Load : &:r0_1, m0_2 +#-----| m0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 +#-----| m0_5(unknown) = Chi : total:m754_2, partial:m0_4 +#-----| r0_6(Middle *) = CopyValue : r754_4 +#-----| r0_7(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_6 +# 754| r754_5(glval) = FunctionAddress[operator=] : +#-----| r0_8(glval) = VariableAddress[p#0] : +#-----| r0_9(Middle &) = Load : &:r0_8, m0_2 +#-----| r0_10(glval) = CopyValue : r0_9 +#-----| r0_11(Middle *) = CopyValue : r0_10 +#-----| r0_12(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_11 +#-----| r0_13(glval) = CopyValue : r0_12 +#-----| r0_14(Base &) = CopyValue : r0_13 +# 754| r754_6(Base &) = Call : func:r754_5, this:r0_7, 0:r0_14 +# 754| m754_7(unknown) = ^CallSideEffect : ~m0_5 +# 754| m754_8(unknown) = Chi : total:m0_5, partial:m754_7 +#-----| v0_15(void) = ^BufferReadSideEffect[-1] : &:r0_7, ~m754_8 +#-----| v0_16(void) = ^BufferReadSideEffect[0] : &:r0_14, ~m754_8 +#-----| m0_17(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_7 +#-----| m0_18(unknown) = Chi : total:m754_8, partial:m0_17 +#-----| m0_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_14 +#-----| m0_20(unknown) = Chi : total:m0_18, partial:m0_19 +#-----| r0_21(glval) = CopyValue : r754_6 +#-----| r0_22(Middle *) = CopyValue : r754_4 +#-----| r0_23(glval) = FieldAddress[middle_s] : r0_22 +#-----| r0_24(String *) = CopyValue : r0_23 +# 754| r754_9(glval) = FunctionAddress[operator=] : +#-----| r0_25(glval) = VariableAddress[p#0] : +#-----| r0_26(Middle &) = Load : &:r0_25, m0_2 +#-----| r0_27(glval) = CopyValue : r0_26 +#-----| r0_28(glval) = FieldAddress[middle_s] : r0_27 +#-----| r0_29(String &) = CopyValue : r0_28 +# 754| r754_10(String &) = Call : func:r754_9, this:r0_24, 0:r0_29 +# 754| m754_11(unknown) = ^CallSideEffect : ~m0_20 +# 754| m754_12(unknown) = Chi : total:m0_20, partial:m754_11 +#-----| v0_30(void) = ^BufferReadSideEffect[-1] : &:r0_24, ~m754_12 +#-----| v0_31(void) = ^BufferReadSideEffect[0] : &:r0_29, ~m754_12 +#-----| m0_32(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_24 +#-----| m0_33(unknown) = Chi : total:m754_12, partial:m0_32 +#-----| m0_34(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_29 +#-----| m0_35(unknown) = Chi : total:m0_33, partial:m0_34 +#-----| r0_36(glval) = CopyValue : r754_10 +#-----| r0_37(glval) = VariableAddress[#return] : +#-----| r0_38(Middle *) = CopyValue : r754_4 +#-----| r0_39(glval) = CopyValue : r0_38 +#-----| r0_40(Middle &) = CopyValue : r0_39 +#-----| m0_41(Middle &) = Store : &:r0_37, r0_40 +#-----| v0_42(void) = ReturnIndirection : &:r0_3, ~m0_35 +# 754| r754_13(glval) = VariableAddress[#return] : +# 754| v754_14(void) = ReturnValue : &:r754_13, m0_41 +# 754| v754_15(void) = UnmodeledUse : mu* +# 754| v754_16(void) = AliasedUse : ~m0_35 +# 754| v754_17(void) = ExitFunction : + +# 757| void Middle::Middle() +# 757| Block 0 +# 757| v757_1(void) = EnterFunction : +# 757| m757_2(unknown) = AliasedDefinition : +# 757| mu757_3(unknown) = UnmodeledDefinition : +# 757| r757_4(glval) = InitializeThis : +# 757| r757_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r757_4 +# 757| r757_6(glval) = FunctionAddress[Base] : +# 757| v757_7(void) = Call : func:r757_6, this:r757_5 +# 757| m757_8(unknown) = ^CallSideEffect : ~m757_2 +# 757| m757_9(unknown) = Chi : total:m757_2, partial:m757_8 +# 757| m757_10(Base) = ^IndirectMayWriteSideEffect[-1] : &:r757_5 +# 757| m757_11(unknown) = Chi : total:m757_9, partial:m757_10 +# 757| r757_12(glval) = FieldAddress[middle_s] : r757_4 +# 757| r757_13(glval) = FunctionAddress[String] : +# 757| v757_14(void) = Call : func:r757_13, this:r757_12 +# 757| m757_15(unknown) = ^CallSideEffect : ~m757_11 +# 757| m757_16(unknown) = Chi : total:m757_11, partial:m757_15 +# 757| m757_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r757_12 +# 757| m757_18(unknown) = Chi : total:m757_16, partial:m757_17 +# 758| v758_1(void) = NoOp : +# 757| v757_19(void) = ReturnVoid : +# 757| v757_20(void) = UnmodeledUse : mu* +# 757| v757_21(void) = AliasedUse : ~m757_18 +# 757| v757_22(void) = ExitFunction : + +# 759| void Middle::~Middle() +# 759| Block 0 +# 759| v759_1(void) = EnterFunction : +# 759| m759_2(unknown) = AliasedDefinition : +# 759| mu759_3(unknown) = UnmodeledDefinition : +# 759| r759_4(glval) = InitializeThis : +# 760| v760_1(void) = NoOp : +# 760| r760_2(glval) = FieldAddress[middle_s] : r759_4 +# 760| r760_3(glval) = FunctionAddress[~String] : +# 760| v760_4(void) = Call : func:r760_3, this:r760_2 +# 760| m760_5(unknown) = ^CallSideEffect : ~m759_2 +# 760| m760_6(unknown) = Chi : total:m759_2, partial:m760_5 +# 760| r760_7(glval) = ConvertToNonVirtualBase[Middle : Base] : r759_4 +# 760| r760_8(glval) = FunctionAddress[~Base] : +# 760| v760_9(void) = Call : func:r760_8, this:r760_7 +# 760| m760_10(unknown) = ^CallSideEffect : ~m760_6 +# 760| m760_11(unknown) = Chi : total:m760_6, partial:m760_10 +# 759| v759_5(void) = ReturnVoid : +# 759| v759_6(void) = UnmodeledUse : mu* +# 759| v759_7(void) = AliasedUse : ~m760_11 +# 759| v759_8(void) = ExitFunction : + +# 763| Derived& Derived::operator=(Derived const&) +# 763| Block 0 +# 763| v763_1(void) = EnterFunction : +# 763| m763_2(unknown) = AliasedDefinition : +# 763| mu763_3(unknown) = UnmodeledDefinition : +# 763| r763_4(glval) = InitializeThis : +#-----| r0_1(glval) = VariableAddress[p#0] : +#-----| m0_2(Derived &) = InitializeParameter[p#0] : &:r0_1 +#-----| r0_3(Derived &) = Load : &:r0_1, m0_2 +#-----| m0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 +#-----| m0_5(unknown) = Chi : total:m763_2, partial:m0_4 +#-----| r0_6(Derived *) = CopyValue : r763_4 +#-----| r0_7(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_6 +# 763| r763_5(glval) = FunctionAddress[operator=] : +#-----| r0_8(glval) = VariableAddress[p#0] : +#-----| r0_9(Derived &) = Load : &:r0_8, m0_2 +#-----| r0_10(glval) = CopyValue : r0_9 +#-----| r0_11(Derived *) = CopyValue : r0_10 +#-----| r0_12(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_11 +#-----| r0_13(glval) = CopyValue : r0_12 +#-----| r0_14(Middle &) = CopyValue : r0_13 +# 763| r763_6(Middle &) = Call : func:r763_5, this:r0_7, 0:r0_14 +# 763| m763_7(unknown) = ^CallSideEffect : ~m0_5 +# 763| m763_8(unknown) = Chi : total:m0_5, partial:m763_7 +#-----| v0_15(void) = ^BufferReadSideEffect[-1] : &:r0_7, ~m763_8 +#-----| v0_16(void) = ^BufferReadSideEffect[0] : &:r0_14, ~m763_8 +#-----| m0_17(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_7 +#-----| m0_18(unknown) = Chi : total:m763_8, partial:m0_17 +#-----| m0_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_14 +#-----| m0_20(unknown) = Chi : total:m0_18, partial:m0_19 +#-----| r0_21(glval) = CopyValue : r763_6 +#-----| r0_22(Derived *) = CopyValue : r763_4 +#-----| r0_23(glval) = FieldAddress[derived_s] : r0_22 +#-----| r0_24(String *) = CopyValue : r0_23 +# 763| r763_9(glval) = FunctionAddress[operator=] : +#-----| r0_25(glval) = VariableAddress[p#0] : +#-----| r0_26(Derived &) = Load : &:r0_25, m0_2 +#-----| r0_27(glval) = CopyValue : r0_26 +#-----| r0_28(glval) = FieldAddress[derived_s] : r0_27 +#-----| r0_29(String &) = CopyValue : r0_28 +# 763| r763_10(String &) = Call : func:r763_9, this:r0_24, 0:r0_29 +# 763| m763_11(unknown) = ^CallSideEffect : ~m0_20 +# 763| m763_12(unknown) = Chi : total:m0_20, partial:m763_11 +#-----| v0_30(void) = ^BufferReadSideEffect[-1] : &:r0_24, ~m763_12 +#-----| v0_31(void) = ^BufferReadSideEffect[0] : &:r0_29, ~m763_12 +#-----| m0_32(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_24 +#-----| m0_33(unknown) = Chi : total:m763_12, partial:m0_32 +#-----| m0_34(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_29 +#-----| m0_35(unknown) = Chi : total:m0_33, partial:m0_34 +#-----| r0_36(glval) = CopyValue : r763_10 +#-----| r0_37(glval) = VariableAddress[#return] : +#-----| r0_38(Derived *) = CopyValue : r763_4 +#-----| r0_39(glval) = CopyValue : r0_38 +#-----| r0_40(Derived &) = CopyValue : r0_39 +#-----| m0_41(Derived &) = Store : &:r0_37, r0_40 +#-----| v0_42(void) = ReturnIndirection : &:r0_3, ~m0_35 +# 763| r763_13(glval) = VariableAddress[#return] : +# 763| v763_14(void) = ReturnValue : &:r763_13, m0_41 +# 763| v763_15(void) = UnmodeledUse : mu* +# 763| v763_16(void) = AliasedUse : ~m0_35 +# 763| v763_17(void) = ExitFunction : + +# 766| void Derived::Derived() +# 766| Block 0 +# 766| v766_1(void) = EnterFunction : +# 766| m766_2(unknown) = AliasedDefinition : +# 766| mu766_3(unknown) = UnmodeledDefinition : +# 766| r766_4(glval) = InitializeThis : +# 766| r766_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r766_4 +# 766| r766_6(glval) = FunctionAddress[Middle] : +# 766| v766_7(void) = Call : func:r766_6, this:r766_5 +# 766| m766_8(unknown) = ^CallSideEffect : ~m766_2 +# 766| m766_9(unknown) = Chi : total:m766_2, partial:m766_8 +# 766| m766_10(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r766_5 +# 766| m766_11(unknown) = Chi : total:m766_9, partial:m766_10 +# 766| r766_12(glval) = FieldAddress[derived_s] : r766_4 +# 766| r766_13(glval) = FunctionAddress[String] : +# 766| v766_14(void) = Call : func:r766_13, this:r766_12 +# 766| m766_15(unknown) = ^CallSideEffect : ~m766_11 +# 766| m766_16(unknown) = Chi : total:m766_11, partial:m766_15 +# 766| m766_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r766_12 +# 766| m766_18(unknown) = Chi : total:m766_16, partial:m766_17 +# 767| v767_1(void) = NoOp : +# 766| v766_19(void) = ReturnVoid : +# 766| v766_20(void) = UnmodeledUse : mu* +# 766| v766_21(void) = AliasedUse : ~m766_18 +# 766| v766_22(void) = ExitFunction : + +# 768| void Derived::~Derived() +# 768| Block 0 +# 768| v768_1(void) = EnterFunction : +# 768| m768_2(unknown) = AliasedDefinition : +# 768| mu768_3(unknown) = UnmodeledDefinition : +# 768| r768_4(glval) = InitializeThis : +# 769| v769_1(void) = NoOp : +# 769| r769_2(glval) = FieldAddress[derived_s] : r768_4 +# 769| r769_3(glval) = FunctionAddress[~String] : +# 769| v769_4(void) = Call : func:r769_3, this:r769_2 +# 769| m769_5(unknown) = ^CallSideEffect : ~m768_2 +# 769| m769_6(unknown) = Chi : total:m768_2, partial:m769_5 +# 769| r769_7(glval) = ConvertToNonVirtualBase[Derived : Middle] : r768_4 +# 769| r769_8(glval) = FunctionAddress[~Middle] : +# 769| v769_9(void) = Call : func:r769_8, this:r769_7 +# 769| m769_10(unknown) = ^CallSideEffect : ~m769_6 +# 769| m769_11(unknown) = Chi : total:m769_6, partial:m769_10 +# 768| v768_5(void) = ReturnVoid : +# 768| v768_6(void) = UnmodeledUse : mu* +# 768| v768_7(void) = AliasedUse : ~m769_11 +# 768| v768_8(void) = ExitFunction : + +# 775| void MiddleVB1::MiddleVB1() +# 775| Block 0 +# 775| v775_1(void) = EnterFunction : +# 775| m775_2(unknown) = AliasedDefinition : +# 775| mu775_3(unknown) = UnmodeledDefinition : +# 775| r775_4(glval) = InitializeThis : +# 775| r775_5(glval) = ConvertToNonVirtualBase[MiddleVB1 : Base] : r775_4 +# 775| r775_6(glval) = FunctionAddress[Base] : +# 775| v775_7(void) = Call : func:r775_6, this:r775_5 +# 775| m775_8(unknown) = ^CallSideEffect : ~m775_2 +# 775| m775_9(unknown) = Chi : total:m775_2, partial:m775_8 +# 775| m775_10(Base) = ^IndirectMayWriteSideEffect[-1] : &:r775_5 +# 775| m775_11(unknown) = Chi : total:m775_9, partial:m775_10 +# 775| r775_12(glval) = FieldAddress[middlevb1_s] : r775_4 +# 775| r775_13(glval) = FunctionAddress[String] : +# 775| v775_14(void) = Call : func:r775_13, this:r775_12 +# 775| m775_15(unknown) = ^CallSideEffect : ~m775_11 +# 775| m775_16(unknown) = Chi : total:m775_11, partial:m775_15 +# 775| m775_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r775_12 +# 775| m775_18(unknown) = Chi : total:m775_16, partial:m775_17 +# 776| v776_1(void) = NoOp : +# 775| v775_19(void) = ReturnVoid : +# 775| v775_20(void) = UnmodeledUse : mu* +# 775| v775_21(void) = AliasedUse : ~m775_18 +# 775| v775_22(void) = ExitFunction : + +# 777| void MiddleVB1::~MiddleVB1() +# 777| Block 0 +# 777| v777_1(void) = EnterFunction : +# 777| m777_2(unknown) = AliasedDefinition : +# 777| mu777_3(unknown) = UnmodeledDefinition : +# 777| r777_4(glval) = InitializeThis : +# 778| v778_1(void) = NoOp : +# 778| r778_2(glval) = FieldAddress[middlevb1_s] : r777_4 +# 778| r778_3(glval) = FunctionAddress[~String] : +# 778| v778_4(void) = Call : func:r778_3, this:r778_2 +# 778| m778_5(unknown) = ^CallSideEffect : ~m777_2 +# 778| m778_6(unknown) = Chi : total:m777_2, partial:m778_5 +# 778| r778_7(glval) = ConvertToNonVirtualBase[MiddleVB1 : Base] : r777_4 +# 778| r778_8(glval) = FunctionAddress[~Base] : +# 778| v778_9(void) = Call : func:r778_8, this:r778_7 +# 778| m778_10(unknown) = ^CallSideEffect : ~m778_6 +# 778| m778_11(unknown) = Chi : total:m778_6, partial:m778_10 +# 777| v777_5(void) = ReturnVoid : +# 777| v777_6(void) = UnmodeledUse : mu* +# 777| v777_7(void) = AliasedUse : ~m778_11 +# 777| v777_8(void) = ExitFunction : + +# 784| void MiddleVB2::MiddleVB2() +# 784| Block 0 +# 784| v784_1(void) = EnterFunction : +# 784| m784_2(unknown) = AliasedDefinition : +# 784| mu784_3(unknown) = UnmodeledDefinition : +# 784| r784_4(glval) = InitializeThis : +# 784| r784_5(glval) = ConvertToNonVirtualBase[MiddleVB2 : Base] : r784_4 +# 784| r784_6(glval) = FunctionAddress[Base] : +# 784| v784_7(void) = Call : func:r784_6, this:r784_5 +# 784| m784_8(unknown) = ^CallSideEffect : ~m784_2 +# 784| m784_9(unknown) = Chi : total:m784_2, partial:m784_8 +# 784| m784_10(Base) = ^IndirectMayWriteSideEffect[-1] : &:r784_5 +# 784| m784_11(unknown) = Chi : total:m784_9, partial:m784_10 +# 784| r784_12(glval) = FieldAddress[middlevb2_s] : r784_4 +# 784| r784_13(glval) = FunctionAddress[String] : +# 784| v784_14(void) = Call : func:r784_13, this:r784_12 +# 784| m784_15(unknown) = ^CallSideEffect : ~m784_11 +# 784| m784_16(unknown) = Chi : total:m784_11, partial:m784_15 +# 784| m784_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r784_12 +# 784| m784_18(unknown) = Chi : total:m784_16, partial:m784_17 +# 785| v785_1(void) = NoOp : +# 784| v784_19(void) = ReturnVoid : +# 784| v784_20(void) = UnmodeledUse : mu* +# 784| v784_21(void) = AliasedUse : ~m784_18 +# 784| v784_22(void) = ExitFunction : + +# 786| void MiddleVB2::~MiddleVB2() +# 786| Block 0 +# 786| v786_1(void) = EnterFunction : +# 786| m786_2(unknown) = AliasedDefinition : +# 786| mu786_3(unknown) = UnmodeledDefinition : +# 786| r786_4(glval) = InitializeThis : +# 787| v787_1(void) = NoOp : +# 787| r787_2(glval) = FieldAddress[middlevb2_s] : r786_4 +# 787| r787_3(glval) = FunctionAddress[~String] : +# 787| v787_4(void) = Call : func:r787_3, this:r787_2 +# 787| m787_5(unknown) = ^CallSideEffect : ~m786_2 +# 787| m787_6(unknown) = Chi : total:m786_2, partial:m787_5 +# 787| r787_7(glval) = ConvertToNonVirtualBase[MiddleVB2 : Base] : r786_4 +# 787| r787_8(glval) = FunctionAddress[~Base] : +# 787| v787_9(void) = Call : func:r787_8, this:r787_7 +# 787| m787_10(unknown) = ^CallSideEffect : ~m787_6 +# 787| m787_11(unknown) = Chi : total:m787_6, partial:m787_10 +# 786| v786_5(void) = ReturnVoid : +# 786| v786_6(void) = UnmodeledUse : mu* +# 786| v786_7(void) = AliasedUse : ~m787_11 +# 786| v786_8(void) = ExitFunction : + +# 793| void DerivedVB::DerivedVB() +# 793| Block 0 +# 793| v793_1(void) = EnterFunction : +# 793| m793_2(unknown) = AliasedDefinition : +# 793| mu793_3(unknown) = UnmodeledDefinition : +# 793| r793_4(glval) = InitializeThis : +# 793| r793_5(glval) = ConvertToNonVirtualBase[DerivedVB : Base] : r793_4 +# 793| r793_6(glval) = FunctionAddress[Base] : +# 793| v793_7(void) = Call : func:r793_6, this:r793_5 +# 793| m793_8(unknown) = ^CallSideEffect : ~m793_2 +# 793| m793_9(unknown) = Chi : total:m793_2, partial:m793_8 +# 793| m793_10(Base) = ^IndirectMayWriteSideEffect[-1] : &:r793_5 +# 793| m793_11(unknown) = Chi : total:m793_9, partial:m793_10 +# 793| r793_12(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB1] : r793_4 +# 793| r793_13(glval) = FunctionAddress[MiddleVB1] : +# 793| v793_14(void) = Call : func:r793_13, this:r793_12 +# 793| m793_15(unknown) = ^CallSideEffect : ~m793_11 +# 793| m793_16(unknown) = Chi : total:m793_11, partial:m793_15 +# 793| m793_17(MiddleVB1) = ^IndirectMayWriteSideEffect[-1] : &:r793_12 +# 793| m793_18(unknown) = Chi : total:m793_16, partial:m793_17 +# 793| r793_19(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB2] : r793_4 +# 793| r793_20(glval) = FunctionAddress[MiddleVB2] : +# 793| v793_21(void) = Call : func:r793_20, this:r793_19 +# 793| m793_22(unknown) = ^CallSideEffect : ~m793_18 +# 793| m793_23(unknown) = Chi : total:m793_18, partial:m793_22 +# 793| m793_24(MiddleVB2) = ^IndirectMayWriteSideEffect[-1] : &:r793_19 +# 793| m793_25(unknown) = Chi : total:m793_23, partial:m793_24 +# 793| r793_26(glval) = FieldAddress[derivedvb_s] : r793_4 +# 793| r793_27(glval) = FunctionAddress[String] : +# 793| v793_28(void) = Call : func:r793_27, this:r793_26 +# 793| m793_29(unknown) = ^CallSideEffect : ~m793_25 +# 793| m793_30(unknown) = Chi : total:m793_25, partial:m793_29 +# 793| m793_31(String) = ^IndirectMayWriteSideEffect[-1] : &:r793_26 +# 793| m793_32(unknown) = Chi : total:m793_30, partial:m793_31 +# 794| v794_1(void) = NoOp : +# 793| v793_33(void) = ReturnVoid : +# 793| v793_34(void) = UnmodeledUse : mu* +# 793| v793_35(void) = AliasedUse : ~m793_32 +# 793| v793_36(void) = ExitFunction : + +# 795| void DerivedVB::~DerivedVB() +# 795| Block 0 +# 795| v795_1(void) = EnterFunction : +# 795| m795_2(unknown) = AliasedDefinition : +# 795| mu795_3(unknown) = UnmodeledDefinition : +# 795| r795_4(glval) = InitializeThis : +# 796| v796_1(void) = NoOp : +# 796| r796_2(glval) = FieldAddress[derivedvb_s] : r795_4 +# 796| r796_3(glval) = FunctionAddress[~String] : +# 796| v796_4(void) = Call : func:r796_3, this:r796_2 +# 796| m796_5(unknown) = ^CallSideEffect : ~m795_2 +# 796| m796_6(unknown) = Chi : total:m795_2, partial:m796_5 +# 796| r796_7(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB2] : r795_4 +# 796| r796_8(glval) = FunctionAddress[~MiddleVB2] : +# 796| v796_9(void) = Call : func:r796_8, this:r796_7 +# 796| m796_10(unknown) = ^CallSideEffect : ~m796_6 +# 796| m796_11(unknown) = Chi : total:m796_6, partial:m796_10 +# 796| r796_12(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB1] : r795_4 +# 796| r796_13(glval) = FunctionAddress[~MiddleVB1] : +# 796| v796_14(void) = Call : func:r796_13, this:r796_12 +# 796| m796_15(unknown) = ^CallSideEffect : ~m796_11 +# 796| m796_16(unknown) = Chi : total:m796_11, partial:m796_15 +# 796| r796_17(glval) = ConvertToNonVirtualBase[DerivedVB : Base] : r795_4 +# 796| r796_18(glval) = FunctionAddress[~Base] : +# 796| v796_19(void) = Call : func:r796_18, this:r796_17 +# 796| m796_20(unknown) = ^CallSideEffect : ~m796_16 +# 796| m796_21(unknown) = Chi : total:m796_16, partial:m796_20 +# 795| v795_5(void) = ReturnVoid : +# 795| v795_6(void) = UnmodeledUse : mu* +# 795| v795_7(void) = AliasedUse : ~m796_21 +# 795| v795_8(void) = ExitFunction : + +# 799| void HierarchyConversions() +# 799| Block 0 +# 799| v799_1(void) = EnterFunction : +# 799| m799_2(unknown) = AliasedDefinition : +# 799| mu799_3(unknown) = UnmodeledDefinition : +# 800| r800_1(glval) = VariableAddress[b] : +# 800| m800_2(Base) = Uninitialized[b] : &:r800_1 +# 800| r800_3(glval) = FunctionAddress[Base] : +# 800| v800_4(void) = Call : func:r800_3, this:r800_1 +# 800| m800_5(unknown) = ^CallSideEffect : ~m799_2 +# 800| m800_6(unknown) = Chi : total:m799_2, partial:m800_5 +# 800| m800_7(Base) = ^IndirectMayWriteSideEffect[-1] : &:r800_1 +# 800| m800_8(Base) = Chi : total:m800_2, partial:m800_7 +# 801| r801_1(glval) = VariableAddress[m] : +# 801| m801_2(Middle) = Uninitialized[m] : &:r801_1 +# 801| r801_3(glval) = FunctionAddress[Middle] : +# 801| v801_4(void) = Call : func:r801_3, this:r801_1 +# 801| m801_5(unknown) = ^CallSideEffect : ~m800_6 +# 801| m801_6(unknown) = Chi : total:m800_6, partial:m801_5 +# 801| m801_7(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r801_1 +# 801| m801_8(Middle) = Chi : total:m801_2, partial:m801_7 +# 802| r802_1(glval) = VariableAddress[d] : +# 802| m802_2(Derived) = Uninitialized[d] : &:r802_1 +# 802| r802_3(glval) = FunctionAddress[Derived] : +# 802| v802_4(void) = Call : func:r802_3, this:r802_1 +# 802| m802_5(unknown) = ^CallSideEffect : ~m801_6 +# 802| m802_6(unknown) = Chi : total:m801_6, partial:m802_5 +# 802| m802_7(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r802_1 +# 802| m802_8(Derived) = Chi : total:m802_2, partial:m802_7 +# 804| r804_1(glval) = VariableAddress[pb] : +# 804| r804_2(glval) = VariableAddress[b] : +# 804| r804_3(Base *) = CopyValue : r804_2 +# 804| m804_4(Base *) = Store : &:r804_1, r804_3 +# 805| r805_1(glval) = VariableAddress[pm] : +# 805| r805_2(glval) = VariableAddress[m] : +# 805| r805_3(Middle *) = CopyValue : r805_2 +# 805| m805_4(Middle *) = Store : &:r805_1, r805_3 +# 806| r806_1(glval) = VariableAddress[pd] : +# 806| r806_2(glval) = VariableAddress[d] : +# 806| r806_3(Derived *) = CopyValue : r806_2 +# 806| m806_4(Derived *) = Store : &:r806_1, r806_3 +# 808| r808_1(glval) = VariableAddress[b] : +# 808| r808_2(glval) = FunctionAddress[operator=] : +# 808| r808_3(glval) = VariableAddress[m] : +# 808| r808_4(glval) = ConvertToNonVirtualBase[Middle : Base] : r808_3 +# 808| r808_5(Base &) = CopyValue : r808_4 +# 808| r808_6(Base &) = Call : func:r808_2, this:r808_1, 0:r808_5 +# 808| m808_7(unknown) = ^CallSideEffect : ~m802_6 +# 808| m808_8(unknown) = Chi : total:m802_6, partial:m808_7 +# 808| v808_9(void) = ^BufferReadSideEffect[-1] : &:r808_1, ~m800_8 +# 808| v808_10(void) = ^BufferReadSideEffect[0] : &:r808_5, ~m801_8 +# 808| m808_11(Base) = ^IndirectMayWriteSideEffect[-1] : &:r808_1 +# 808| m808_12(Base) = Chi : total:m800_8, partial:m808_11 +# 808| m808_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r808_5 +# 808| m808_14(Middle) = Chi : total:m801_8, partial:m808_13 +# 808| r808_15(glval) = CopyValue : r808_6 +# 809| r809_1(glval) = VariableAddress[b] : +# 809| r809_2(glval) = FunctionAddress[operator=] : +# 809| r809_3(glval) = FunctionAddress[Base] : +# 809| r809_4(glval) = VariableAddress[m] : +# 809| r809_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r809_4 +# 809| r809_6(Base &) = CopyValue : r809_5 +# 809| v809_7(void) = Call : func:r809_3, 0:r809_6 +# 809| m809_8(unknown) = ^CallSideEffect : ~m808_8 +# 809| m809_9(unknown) = Chi : total:m808_8, partial:m809_8 +# 809| m809_10(Base) = ^IndirectMayWriteSideEffect[-1] : +# 809| m809_11(unknown) = Chi : total:m809_9, partial:m809_10 +# 809| v809_12(void) = ^BufferReadSideEffect[0] : &:r809_6, ~m808_14 +# 809| m809_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r809_6 +# 809| m809_14(Middle) = Chi : total:m808_14, partial:m809_13 +# 809| r809_15(glval) = Convert : v809_7 +# 809| r809_16(Base &) = CopyValue : r809_15 +# 809| r809_17(Base &) = Call : func:r809_2, this:r809_1, 0:r809_16 +# 809| m809_18(unknown) = ^CallSideEffect : ~m809_11 +# 809| m809_19(unknown) = Chi : total:m809_11, partial:m809_18 +# 809| v809_20(void) = ^BufferReadSideEffect[-1] : &:r809_1, ~m808_12 +# 809| v809_21(void) = ^BufferReadSideEffect[0] : &:r809_16, ~m809_19 +# 809| m809_22(Base) = ^IndirectMayWriteSideEffect[-1] : &:r809_1 +# 809| m809_23(Base) = Chi : total:m808_12, partial:m809_22 +# 809| m809_24(unknown) = ^BufferMayWriteSideEffect[0] : &:r809_16 +# 809| m809_25(unknown) = Chi : total:m809_19, partial:m809_24 +# 809| r809_26(glval) = CopyValue : r809_17 +# 810| r810_1(glval) = VariableAddress[b] : +# 810| r810_2(glval) = FunctionAddress[operator=] : +# 810| r810_3(glval) = FunctionAddress[Base] : +# 810| r810_4(glval) = VariableAddress[m] : +# 810| r810_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r810_4 +# 810| r810_6(Base &) = CopyValue : r810_5 +# 810| v810_7(void) = Call : func:r810_3, 0:r810_6 +# 810| m810_8(unknown) = ^CallSideEffect : ~m809_25 +# 810| m810_9(unknown) = Chi : total:m809_25, partial:m810_8 +# 810| m810_10(Base) = ^IndirectMayWriteSideEffect[-1] : +# 810| m810_11(unknown) = Chi : total:m810_9, partial:m810_10 +# 810| v810_12(void) = ^BufferReadSideEffect[0] : &:r810_6, ~m809_14 +# 810| m810_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r810_6 +# 810| m810_14(Middle) = Chi : total:m809_14, partial:m810_13 +# 810| r810_15(glval) = Convert : v810_7 +# 810| r810_16(Base &) = CopyValue : r810_15 +# 810| r810_17(Base &) = Call : func:r810_2, this:r810_1, 0:r810_16 +# 810| m810_18(unknown) = ^CallSideEffect : ~m810_11 +# 810| m810_19(unknown) = Chi : total:m810_11, partial:m810_18 +# 810| v810_20(void) = ^BufferReadSideEffect[-1] : &:r810_1, ~m809_23 +# 810| v810_21(void) = ^BufferReadSideEffect[0] : &:r810_16, ~m810_19 +# 810| m810_22(Base) = ^IndirectMayWriteSideEffect[-1] : &:r810_1 +# 810| m810_23(Base) = Chi : total:m809_23, partial:m810_22 +# 810| m810_24(unknown) = ^BufferMayWriteSideEffect[0] : &:r810_16 +# 810| m810_25(unknown) = Chi : total:m810_19, partial:m810_24 +# 810| r810_26(glval) = CopyValue : r810_17 +# 811| r811_1(glval) = VariableAddress[pm] : +# 811| r811_2(Middle *) = Load : &:r811_1, m805_4 +# 811| r811_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r811_2 +# 811| r811_4(glval) = VariableAddress[pb] : +# 811| m811_5(Base *) = Store : &:r811_4, r811_3 +# 812| r812_1(glval) = VariableAddress[pm] : +# 812| r812_2(Middle *) = Load : &:r812_1, m805_4 +# 812| r812_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r812_2 +# 812| r812_4(glval) = VariableAddress[pb] : +# 812| m812_5(Base *) = Store : &:r812_4, r812_3 +# 813| r813_1(glval) = VariableAddress[pm] : +# 813| r813_2(Middle *) = Load : &:r813_1, m805_4 +# 813| r813_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r813_2 +# 813| r813_4(glval) = VariableAddress[pb] : +# 813| m813_5(Base *) = Store : &:r813_4, r813_3 +# 814| r814_1(glval) = VariableAddress[pm] : +# 814| r814_2(Middle *) = Load : &:r814_1, m805_4 +# 814| r814_3(Base *) = Convert : r814_2 +# 814| r814_4(glval) = VariableAddress[pb] : +# 814| m814_5(Base *) = Store : &:r814_4, r814_3 +# 816| r816_1(glval) = VariableAddress[m] : +# 816| r816_2(glval) = FunctionAddress[operator=] : +# 816| r816_3(glval) = VariableAddress[b] : +# 816| r816_4(glval) = ConvertToDerived[Middle : Base] : r816_3 +# 816| r816_5(glval) = Convert : r816_4 +# 816| r816_6(Middle &) = CopyValue : r816_5 +# 816| r816_7(Middle &) = Call : func:r816_2, this:r816_1, 0:r816_6 +# 816| m816_8(unknown) = ^CallSideEffect : ~m810_25 +# 816| m816_9(unknown) = Chi : total:m810_25, partial:m816_8 +# 816| v816_10(void) = ^BufferReadSideEffect[-1] : &:r816_1, ~m810_14 +# 816| v816_11(void) = ^BufferReadSideEffect[0] : &:r816_6, ~m810_23 +# 816| m816_12(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r816_1 +# 816| m816_13(Middle) = Chi : total:m810_14, partial:m816_12 +# 816| m816_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r816_6 +# 816| m816_15(Base) = Chi : total:m810_23, partial:m816_14 +# 816| r816_16(glval) = CopyValue : r816_7 +# 817| r817_1(glval) = VariableAddress[m] : +# 817| r817_2(glval) = FunctionAddress[operator=] : +# 817| r817_3(glval) = VariableAddress[b] : +# 817| r817_4(glval) = ConvertToDerived[Middle : Base] : r817_3 +# 817| r817_5(glval) = Convert : r817_4 +# 817| r817_6(Middle &) = CopyValue : r817_5 +# 817| r817_7(Middle &) = Call : func:r817_2, this:r817_1, 0:r817_6 +# 817| m817_8(unknown) = ^CallSideEffect : ~m816_9 +# 817| m817_9(unknown) = Chi : total:m816_9, partial:m817_8 +# 817| v817_10(void) = ^BufferReadSideEffect[-1] : &:r817_1, ~m816_13 +# 817| v817_11(void) = ^BufferReadSideEffect[0] : &:r817_6, ~m816_15 +# 817| m817_12(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r817_1 +# 817| m817_13(Middle) = Chi : total:m816_13, partial:m817_12 +# 817| m817_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r817_6 +# 817| m817_15(Base) = Chi : total:m816_15, partial:m817_14 +# 817| r817_16(glval) = CopyValue : r817_7 +# 818| r818_1(glval) = VariableAddress[pb] : +# 818| r818_2(Base *) = Load : &:r818_1, m814_5 +# 818| r818_3(Middle *) = ConvertToDerived[Middle : Base] : r818_2 +# 818| r818_4(glval) = VariableAddress[pm] : +# 818| m818_5(Middle *) = Store : &:r818_4, r818_3 +# 819| r819_1(glval) = VariableAddress[pb] : +# 819| r819_2(Base *) = Load : &:r819_1, m814_5 +# 819| r819_3(Middle *) = ConvertToDerived[Middle : Base] : r819_2 +# 819| r819_4(glval) = VariableAddress[pm] : +# 819| m819_5(Middle *) = Store : &:r819_4, r819_3 +# 820| r820_1(glval) = VariableAddress[pb] : +# 820| r820_2(Base *) = Load : &:r820_1, m814_5 +# 820| r820_3(Middle *) = Convert : r820_2 +# 820| r820_4(glval) = VariableAddress[pm] : +# 820| m820_5(Middle *) = Store : &:r820_4, r820_3 +# 822| r822_1(glval) = VariableAddress[b] : +# 822| r822_2(glval) = FunctionAddress[operator=] : +# 822| r822_3(glval) = VariableAddress[d] : +# 822| r822_4(glval) = ConvertToNonVirtualBase[Derived : Middle] : r822_3 +# 822| r822_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r822_4 +# 822| r822_6(Base &) = CopyValue : r822_5 +# 822| r822_7(Base &) = Call : func:r822_2, this:r822_1, 0:r822_6 +# 822| m822_8(unknown) = ^CallSideEffect : ~m817_9 +# 822| m822_9(unknown) = Chi : total:m817_9, partial:m822_8 +# 822| v822_10(void) = ^BufferReadSideEffect[-1] : &:r822_1, ~m817_15 +# 822| v822_11(void) = ^BufferReadSideEffect[0] : &:r822_6, ~m802_8 +# 822| m822_12(Base) = ^IndirectMayWriteSideEffect[-1] : &:r822_1 +# 822| m822_13(Base) = Chi : total:m817_15, partial:m822_12 +# 822| m822_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r822_6 +# 822| m822_15(Derived) = Chi : total:m802_8, partial:m822_14 +# 822| r822_16(glval) = CopyValue : r822_7 +# 823| r823_1(glval) = VariableAddress[b] : +# 823| r823_2(glval) = FunctionAddress[operator=] : +# 823| r823_3(glval) = FunctionAddress[Base] : +# 823| r823_4(glval) = VariableAddress[d] : +# 823| r823_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r823_4 +# 823| r823_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r823_5 +# 823| r823_7(Base &) = CopyValue : r823_6 +# 823| v823_8(void) = Call : func:r823_3, 0:r823_7 +# 823| m823_9(unknown) = ^CallSideEffect : ~m822_9 +# 823| m823_10(unknown) = Chi : total:m822_9, partial:m823_9 +# 823| m823_11(Base) = ^IndirectMayWriteSideEffect[-1] : +# 823| m823_12(unknown) = Chi : total:m823_10, partial:m823_11 +# 823| v823_13(void) = ^BufferReadSideEffect[0] : &:r823_7, ~m822_15 +# 823| m823_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r823_7 +# 823| m823_15(Derived) = Chi : total:m822_15, partial:m823_14 +# 823| r823_16(glval) = Convert : v823_8 +# 823| r823_17(Base &) = CopyValue : r823_16 +# 823| r823_18(Base &) = Call : func:r823_2, this:r823_1, 0:r823_17 +# 823| m823_19(unknown) = ^CallSideEffect : ~m823_12 +# 823| m823_20(unknown) = Chi : total:m823_12, partial:m823_19 +# 823| v823_21(void) = ^BufferReadSideEffect[-1] : &:r823_1, ~m822_13 +# 823| v823_22(void) = ^BufferReadSideEffect[0] : &:r823_17, ~m823_20 +# 823| m823_23(Base) = ^IndirectMayWriteSideEffect[-1] : &:r823_1 +# 823| m823_24(Base) = Chi : total:m822_13, partial:m823_23 +# 823| m823_25(unknown) = ^BufferMayWriteSideEffect[0] : &:r823_17 +# 823| m823_26(unknown) = Chi : total:m823_20, partial:m823_25 +# 823| r823_27(glval) = CopyValue : r823_18 +# 824| r824_1(glval) = VariableAddress[b] : +# 824| r824_2(glval) = FunctionAddress[operator=] : +# 824| r824_3(glval) = FunctionAddress[Base] : +# 824| r824_4(glval) = VariableAddress[d] : +# 824| r824_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r824_4 +# 824| r824_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r824_5 +# 824| r824_7(Base &) = CopyValue : r824_6 +# 824| v824_8(void) = Call : func:r824_3, 0:r824_7 +# 824| m824_9(unknown) = ^CallSideEffect : ~m823_26 +# 824| m824_10(unknown) = Chi : total:m823_26, partial:m824_9 +# 824| m824_11(Base) = ^IndirectMayWriteSideEffect[-1] : +# 824| m824_12(unknown) = Chi : total:m824_10, partial:m824_11 +# 824| v824_13(void) = ^BufferReadSideEffect[0] : &:r824_7, ~m823_15 +# 824| m824_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r824_7 +# 824| m824_15(Derived) = Chi : total:m823_15, partial:m824_14 +# 824| r824_16(glval) = Convert : v824_8 +# 824| r824_17(Base &) = CopyValue : r824_16 +# 824| r824_18(Base &) = Call : func:r824_2, this:r824_1, 0:r824_17 +# 824| m824_19(unknown) = ^CallSideEffect : ~m824_12 +# 824| m824_20(unknown) = Chi : total:m824_12, partial:m824_19 +# 824| v824_21(void) = ^BufferReadSideEffect[-1] : &:r824_1, ~m823_24 +# 824| v824_22(void) = ^BufferReadSideEffect[0] : &:r824_17, ~m824_20 +# 824| m824_23(Base) = ^IndirectMayWriteSideEffect[-1] : &:r824_1 +# 824| m824_24(Base) = Chi : total:m823_24, partial:m824_23 +# 824| m824_25(unknown) = ^BufferMayWriteSideEffect[0] : &:r824_17 +# 824| m824_26(unknown) = Chi : total:m824_20, partial:m824_25 +# 824| r824_27(glval) = CopyValue : r824_18 +# 825| r825_1(glval) = VariableAddress[pd] : +# 825| r825_2(Derived *) = Load : &:r825_1, m806_4 +# 825| r825_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r825_2 +# 825| r825_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r825_3 +# 825| r825_5(glval) = VariableAddress[pb] : +# 825| m825_6(Base *) = Store : &:r825_5, r825_4 +# 826| r826_1(glval) = VariableAddress[pd] : +# 826| r826_2(Derived *) = Load : &:r826_1, m806_4 +# 826| r826_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r826_2 +# 826| r826_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r826_3 +# 826| r826_5(glval) = VariableAddress[pb] : +# 826| m826_6(Base *) = Store : &:r826_5, r826_4 +# 827| r827_1(glval) = VariableAddress[pd] : +# 827| r827_2(Derived *) = Load : &:r827_1, m806_4 +# 827| r827_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r827_2 +# 827| r827_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r827_3 +# 827| r827_5(glval) = VariableAddress[pb] : +# 827| m827_6(Base *) = Store : &:r827_5, r827_4 +# 828| r828_1(glval) = VariableAddress[pd] : +# 828| r828_2(Derived *) = Load : &:r828_1, m806_4 +# 828| r828_3(Base *) = Convert : r828_2 +# 828| r828_4(glval) = VariableAddress[pb] : +# 828| m828_5(Base *) = Store : &:r828_4, r828_3 +# 830| r830_1(glval) = VariableAddress[d] : +# 830| r830_2(glval) = FunctionAddress[operator=] : +# 830| r830_3(glval) = VariableAddress[b] : +# 830| r830_4(glval) = ConvertToDerived[Middle : Base] : r830_3 +# 830| r830_5(glval) = ConvertToDerived[Derived : Middle] : r830_4 +# 830| r830_6(glval) = Convert : r830_5 +# 830| r830_7(Derived &) = CopyValue : r830_6 +# 830| r830_8(Derived &) = Call : func:r830_2, this:r830_1, 0:r830_7 +# 830| m830_9(unknown) = ^CallSideEffect : ~m824_26 +# 830| m830_10(unknown) = Chi : total:m824_26, partial:m830_9 +# 830| v830_11(void) = ^BufferReadSideEffect[-1] : &:r830_1, ~m824_15 +# 830| v830_12(void) = ^BufferReadSideEffect[0] : &:r830_7, ~m824_24 +# 830| m830_13(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r830_1 +# 830| m830_14(Derived) = Chi : total:m824_15, partial:m830_13 +# 830| m830_15(unknown) = ^BufferMayWriteSideEffect[0] : &:r830_7 +# 830| m830_16(Base) = Chi : total:m824_24, partial:m830_15 +# 830| r830_17(glval) = CopyValue : r830_8 +# 831| r831_1(glval) = VariableAddress[d] : +# 831| r831_2(glval) = FunctionAddress[operator=] : +# 831| r831_3(glval) = VariableAddress[b] : +# 831| r831_4(glval) = ConvertToDerived[Middle : Base] : r831_3 +# 831| r831_5(glval) = ConvertToDerived[Derived : Middle] : r831_4 +# 831| r831_6(glval) = Convert : r831_5 +# 831| r831_7(Derived &) = CopyValue : r831_6 +# 831| r831_8(Derived &) = Call : func:r831_2, this:r831_1, 0:r831_7 +# 831| m831_9(unknown) = ^CallSideEffect : ~m830_10 +# 831| m831_10(unknown) = Chi : total:m830_10, partial:m831_9 +# 831| v831_11(void) = ^BufferReadSideEffect[-1] : &:r831_1, ~m830_14 +# 831| v831_12(void) = ^BufferReadSideEffect[0] : &:r831_7, ~m830_16 +# 831| m831_13(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r831_1 +# 831| m831_14(Derived) = Chi : total:m830_14, partial:m831_13 +# 831| m831_15(unknown) = ^BufferMayWriteSideEffect[0] : &:r831_7 +# 831| m831_16(Base) = Chi : total:m830_16, partial:m831_15 +# 831| r831_17(glval) = CopyValue : r831_8 +# 832| r832_1(glval) = VariableAddress[pb] : +# 832| r832_2(Base *) = Load : &:r832_1, m828_5 +# 832| r832_3(Middle *) = ConvertToDerived[Middle : Base] : r832_2 +# 832| r832_4(Derived *) = ConvertToDerived[Derived : Middle] : r832_3 +# 832| r832_5(glval) = VariableAddress[pd] : +# 832| m832_6(Derived *) = Store : &:r832_5, r832_4 +# 833| r833_1(glval) = VariableAddress[pb] : +# 833| r833_2(Base *) = Load : &:r833_1, m828_5 +# 833| r833_3(Middle *) = ConvertToDerived[Middle : Base] : r833_2 +# 833| r833_4(Derived *) = ConvertToDerived[Derived : Middle] : r833_3 +# 833| r833_5(glval) = VariableAddress[pd] : +# 833| m833_6(Derived *) = Store : &:r833_5, r833_4 +# 834| r834_1(glval) = VariableAddress[pb] : +# 834| r834_2(Base *) = Load : &:r834_1, m828_5 +# 834| r834_3(Derived *) = Convert : r834_2 +# 834| r834_4(glval) = VariableAddress[pd] : +# 834| m834_5(Derived *) = Store : &:r834_4, r834_3 +# 836| r836_1(glval) = VariableAddress[pmv] : +# 836| r836_2(MiddleVB1 *) = Constant[0] : +# 836| m836_3(MiddleVB1 *) = Store : &:r836_1, r836_2 +# 837| r837_1(glval) = VariableAddress[pdv] : +# 837| r837_2(DerivedVB *) = Constant[0] : +# 837| m837_3(DerivedVB *) = Store : &:r837_1, r837_2 +# 838| r838_1(glval) = VariableAddress[pmv] : +# 838| r838_2(MiddleVB1 *) = Load : &:r838_1, m836_3 +# 838| r838_3(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r838_2 +# 838| r838_4(glval) = VariableAddress[pb] : +# 838| m838_5(Base *) = Store : &:r838_4, r838_3 +# 839| r839_1(glval) = VariableAddress[pdv] : +# 839| r839_2(DerivedVB *) = Load : &:r839_1, m837_3 +# 839| r839_3(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r839_2 +# 839| r839_4(glval) = VariableAddress[pb] : +# 839| m839_5(Base *) = Store : &:r839_4, r839_3 +# 840| v840_1(void) = NoOp : +# 799| v799_4(void) = ReturnVoid : +# 799| v799_5(void) = UnmodeledUse : mu* +# 799| v799_6(void) = AliasedUse : ~m831_10 +# 799| v799_7(void) = ExitFunction : + +# 842| void PolymorphicBase::PolymorphicBase() +# 842| Block 0 +# 842| v842_1(void) = EnterFunction : +# 842| m842_2(unknown) = AliasedDefinition : +# 842| mu842_3(unknown) = UnmodeledDefinition : +# 842| r842_4(glval) = InitializeThis : +# 842| v842_5(void) = NoOp : +# 842| v842_6(void) = ReturnVoid : +# 842| v842_7(void) = UnmodeledUse : mu* +# 842| v842_8(void) = AliasedUse : ~m842_2 +# 842| v842_9(void) = ExitFunction : + +# 846| void PolymorphicDerived::PolymorphicDerived() +# 846| Block 0 +# 846| v846_1(void) = EnterFunction : +# 846| m846_2(unknown) = AliasedDefinition : +# 846| mu846_3(unknown) = UnmodeledDefinition : +# 846| r846_4(glval) = InitializeThis : +# 846| r846_5(glval) = ConvertToNonVirtualBase[PolymorphicDerived : PolymorphicBase] : r846_4 +# 846| r846_6(glval) = FunctionAddress[PolymorphicBase] : +# 846| v846_7(void) = Call : func:r846_6, this:r846_5 +# 846| m846_8(unknown) = ^CallSideEffect : ~m846_2 +# 846| m846_9(unknown) = Chi : total:m846_2, partial:m846_8 +# 846| m846_10(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r846_5 +# 846| m846_11(unknown) = Chi : total:m846_9, partial:m846_10 +# 846| v846_12(void) = NoOp : +# 846| v846_13(void) = ReturnVoid : +# 846| v846_14(void) = UnmodeledUse : mu* +# 846| v846_15(void) = AliasedUse : ~m846_11 +# 846| v846_16(void) = ExitFunction : + +# 846| void PolymorphicDerived::~PolymorphicDerived() +# 846| Block 0 +# 846| v846_1(void) = EnterFunction : +# 846| m846_2(unknown) = AliasedDefinition : +# 846| mu846_3(unknown) = UnmodeledDefinition : +# 846| r846_4(glval) = InitializeThis : +#-----| v0_1(void) = NoOp : +# 846| r846_5(glval) = ConvertToNonVirtualBase[PolymorphicDerived : PolymorphicBase] : r846_4 +# 846| r846_6(glval) = FunctionAddress[~PolymorphicBase] : +# 846| v846_7(void) = Call : func:r846_6, this:r846_5 +# 846| m846_8(unknown) = ^CallSideEffect : ~m846_2 +# 846| m846_9(unknown) = Chi : total:m846_2, partial:m846_8 +# 846| v846_10(void) = ReturnVoid : +# 846| v846_11(void) = UnmodeledUse : mu* +# 846| v846_12(void) = AliasedUse : ~m846_9 +# 846| v846_13(void) = ExitFunction : + +# 849| void DynamicCast() +# 849| Block 0 +# 849| v849_1(void) = EnterFunction : +# 849| m849_2(unknown) = AliasedDefinition : +# 849| mu849_3(unknown) = UnmodeledDefinition : +# 850| r850_1(glval) = VariableAddress[b] : +# 850| m850_2(PolymorphicBase) = Uninitialized[b] : &:r850_1 +#-----| r0_1(glval) = FunctionAddress[PolymorphicBase] : +#-----| v0_2(void) = Call : func:r0_1, this:r850_1 +#-----| m0_3(unknown) = ^CallSideEffect : ~m849_2 +#-----| m0_4(unknown) = Chi : total:m849_2, partial:m0_3 +#-----| m0_5(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r850_1 +#-----| m0_6(PolymorphicBase) = Chi : total:m850_2, partial:m0_5 +# 851| r851_1(glval) = VariableAddress[d] : +# 851| m851_2(PolymorphicDerived) = Uninitialized[d] : &:r851_1 +# 851| r851_3(glval) = FunctionAddress[PolymorphicDerived] : +# 851| v851_4(void) = Call : func:r851_3, this:r851_1 +# 851| m851_5(unknown) = ^CallSideEffect : ~m0_4 +# 851| m851_6(unknown) = Chi : total:m0_4, partial:m851_5 +# 851| m851_7(PolymorphicDerived) = ^IndirectMayWriteSideEffect[-1] : &:r851_1 +# 851| m851_8(PolymorphicDerived) = Chi : total:m851_2, partial:m851_7 +# 853| r853_1(glval) = VariableAddress[pb] : +# 853| r853_2(glval) = VariableAddress[b] : +# 853| r853_3(PolymorphicBase *) = CopyValue : r853_2 +# 853| m853_4(PolymorphicBase *) = Store : &:r853_1, r853_3 +# 854| r854_1(glval) = VariableAddress[pd] : +# 854| r854_2(glval) = VariableAddress[d] : +# 854| r854_3(PolymorphicDerived *) = CopyValue : r854_2 +# 854| m854_4(PolymorphicDerived *) = Store : &:r854_1, r854_3 +# 857| r857_1(glval) = VariableAddress[pd] : +# 857| r857_2(PolymorphicDerived *) = Load : &:r857_1, m854_4 +# 857| r857_3(PolymorphicBase *) = CheckedConvertOrNull : r857_2 +# 857| r857_4(glval) = VariableAddress[pb] : +# 857| m857_5(PolymorphicBase *) = Store : &:r857_4, r857_3 +# 858| r858_1(glval) = VariableAddress[rb] : +# 858| r858_2(glval) = VariableAddress[d] : +# 858| r858_3(glval) = CheckedConvertOrThrow : r858_2 +# 858| r858_4(PolymorphicBase &) = CopyValue : r858_3 +# 858| m858_5(PolymorphicBase &) = Store : &:r858_1, r858_4 +# 860| r860_1(glval) = VariableAddress[pb] : +# 860| r860_2(PolymorphicBase *) = Load : &:r860_1, m857_5 +# 860| r860_3(PolymorphicDerived *) = CheckedConvertOrNull : r860_2 +# 860| r860_4(glval) = VariableAddress[pd] : +# 860| m860_5(PolymorphicDerived *) = Store : &:r860_4, r860_3 +# 861| r861_1(glval) = VariableAddress[rd] : +# 861| r861_2(glval) = VariableAddress[b] : +# 861| r861_3(glval) = CheckedConvertOrThrow : r861_2 +# 861| r861_4(PolymorphicDerived &) = CopyValue : r861_3 +# 861| m861_5(PolymorphicDerived &) = Store : &:r861_1, r861_4 +# 863| r863_1(glval) = VariableAddress[pv] : +# 863| r863_2(glval) = VariableAddress[pb] : +# 863| r863_3(PolymorphicBase *) = Load : &:r863_2, m857_5 +# 863| r863_4(void *) = DynamicCastToVoid : r863_3 +# 863| m863_5(void *) = Store : &:r863_1, r863_4 +# 864| r864_1(glval) = VariableAddress[pcv] : +# 864| r864_2(glval) = VariableAddress[pd] : +# 864| r864_3(PolymorphicDerived *) = Load : &:r864_2, m860_5 +# 864| r864_4(void *) = DynamicCastToVoid : r864_3 +# 864| m864_5(void *) = Store : &:r864_1, r864_4 +# 865| v865_1(void) = NoOp : +# 849| v849_4(void) = ReturnVoid : +# 849| v849_5(void) = UnmodeledUse : mu* +# 849| v849_6(void) = AliasedUse : ~m851_6 +# 849| v849_7(void) = ExitFunction : + +# 867| void String::String() +# 867| Block 0 +# 867| v867_1(void) = EnterFunction : +# 867| m867_2(unknown) = AliasedDefinition : +# 867| mu867_3(unknown) = UnmodeledDefinition : +# 867| r867_4(glval) = InitializeThis : +# 868| r868_1(glval) = FunctionAddress[String] : +# 868| r868_2(glval) = StringConstant[""] : +# 868| r868_3(char *) = Convert : r868_2 +# 868| v868_4(void) = Call : func:r868_1, this:r867_4, 0:r868_3 +# 868| m868_5(unknown) = ^CallSideEffect : ~m867_2 +# 868| m868_6(unknown) = Chi : total:m867_2, partial:m868_5 +# 868| m868_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r867_4 +# 868| m868_8(unknown) = Chi : total:m868_6, partial:m868_7 +# 868| v868_9(void) = ^BufferReadSideEffect[0] : &:r868_3, ~m867_2 +# 868| m868_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r868_3 +# 868| m868_11(unknown) = Chi : total:m868_8, partial:m868_10 +# 869| v869_1(void) = NoOp : +# 867| v867_5(void) = ReturnVoid : +# 867| v867_6(void) = UnmodeledUse : mu* +# 867| v867_7(void) = AliasedUse : ~m868_11 +# 867| v867_8(void) = ExitFunction : + +# 871| void ArrayConversions() +# 871| Block 0 +# 871| v871_1(void) = EnterFunction : +# 871| m871_2(unknown) = AliasedDefinition : +# 871| mu871_3(unknown) = UnmodeledDefinition : +# 872| r872_1(glval) = VariableAddress[a] : +# 872| m872_2(char[5]) = Uninitialized[a] : &:r872_1 +# 873| r873_1(glval) = VariableAddress[p] : +# 873| r873_2(glval) = VariableAddress[a] : +# 873| r873_3(char *) = Convert : r873_2 +# 873| r873_4(char *) = Convert : r873_3 +# 873| m873_5(char *) = Store : &:r873_1, r873_4 +# 874| r874_1(glval) = StringConstant["test"] : +# 874| r874_2(char *) = Convert : r874_1 +# 874| r874_3(glval) = VariableAddress[p] : +# 874| m874_4(char *) = Store : &:r874_3, r874_2 +# 875| r875_1(glval) = VariableAddress[a] : +# 875| r875_2(char *) = Convert : r875_1 +# 875| r875_3(int) = Constant[0] : +# 875| r875_4(glval) = PointerAdd[1] : r875_2, r875_3 +# 875| r875_5(char *) = CopyValue : r875_4 +# 875| r875_6(char *) = Convert : r875_5 +# 875| r875_7(glval) = VariableAddress[p] : +# 875| m875_8(char *) = Store : &:r875_7, r875_6 +# 876| r876_1(glval) = StringConstant["test"] : +# 876| r876_2(char *) = Convert : r876_1 +# 876| r876_3(int) = Constant[0] : +# 876| r876_4(glval) = PointerAdd[1] : r876_2, r876_3 +# 876| r876_5(char *) = CopyValue : r876_4 +# 876| r876_6(glval) = VariableAddress[p] : +# 876| m876_7(char *) = Store : &:r876_6, r876_5 +# 877| r877_1(glval) = VariableAddress[ra] : +# 877| r877_2(glval) = VariableAddress[a] : +# 877| r877_3(char(&)[5]) = CopyValue : r877_2 +# 877| m877_4(char(&)[5]) = Store : &:r877_1, r877_3 +# 878| r878_1(glval) = VariableAddress[rs] : +# 878| r878_2(glval) = StringConstant["test"] : +# 878| r878_3(char(&)[5]) = CopyValue : r878_2 +# 878| m878_4(char(&)[5]) = Store : &:r878_1, r878_3 +# 879| r879_1(glval) = VariableAddress[pa] : +# 879| r879_2(glval) = VariableAddress[a] : +# 879| r879_3(char(*)[5]) = CopyValue : r879_2 +# 879| r879_4(char(*)[5]) = Convert : r879_3 +# 879| m879_5(char(*)[5]) = Store : &:r879_1, r879_4 +# 880| r880_1(glval) = StringConstant["test"] : +# 880| r880_2(char(*)[5]) = CopyValue : r880_1 +# 880| r880_3(glval) = VariableAddress[pa] : +# 880| m880_4(char(*)[5]) = Store : &:r880_3, r880_2 +# 881| v881_1(void) = NoOp : +# 871| v871_4(void) = ReturnVoid : +# 871| v871_5(void) = UnmodeledUse : mu* +# 871| v871_6(void) = AliasedUse : ~m871_2 +# 871| v871_7(void) = ExitFunction : + +# 883| void FuncPtrConversions(int(*)(int), void*) +# 883| Block 0 +# 883| v883_1(void) = EnterFunction : +# 883| m883_2(unknown) = AliasedDefinition : +# 883| mu883_3(unknown) = UnmodeledDefinition : +# 883| r883_4(glval<..(*)(..)>) = VariableAddress[pfn] : +# 883| m883_5(..(*)(..)) = InitializeParameter[pfn] : &:r883_4 +# 883| r883_6(glval) = VariableAddress[p] : +# 883| m883_7(void *) = InitializeParameter[p] : &:r883_6 +# 883| r883_8(void *) = Load : &:r883_6, m883_7 +# 883| m883_9(unknown) = InitializeIndirection[p] : &:r883_8 +# 883| m883_10(unknown) = Chi : total:m883_2, partial:m883_9 +# 884| r884_1(glval<..(*)(..)>) = VariableAddress[pfn] : +# 884| r884_2(..(*)(..)) = Load : &:r884_1, m883_5 +# 884| r884_3(void *) = Convert : r884_2 +# 884| r884_4(glval) = VariableAddress[p] : +# 884| m884_5(void *) = Store : &:r884_4, r884_3 +# 885| r885_1(glval) = VariableAddress[p] : +# 885| r885_2(void *) = Load : &:r885_1, m884_5 +# 885| r885_3(..(*)(..)) = Convert : r885_2 +# 885| r885_4(glval<..(*)(..)>) = VariableAddress[pfn] : +# 885| m885_5(..(*)(..)) = Store : &:r885_4, r885_3 +# 886| v886_1(void) = NoOp : +# 883| v883_11(void) = ReturnIndirection : &:r883_8, ~m883_10 +# 883| v883_12(void) = ReturnVoid : +# 883| v883_13(void) = UnmodeledUse : mu* +# 883| v883_14(void) = AliasedUse : ~m883_10 +# 883| v883_15(void) = ExitFunction : + +# 888| void VarArgUsage(int) +# 888| Block 0 +# 888| v888_1(void) = EnterFunction : +# 888| m888_2(unknown) = AliasedDefinition : +# 888| mu888_3(unknown) = UnmodeledDefinition : +# 888| r888_4(glval) = VariableAddress[x] : +# 888| m888_5(int) = InitializeParameter[x] : &:r888_4 +# 889| r889_1(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 889| m889_2(__va_list_tag[1]) = Uninitialized[args] : &:r889_1 +# 891| r891_1(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 891| r891_2(__va_list_tag *) = Convert : r891_1 +# 891| r891_3(glval) = VariableAddress[x] : +# 891| v891_4(void) = VarArgsStart : 0:r891_2, 1:r891_3 +# 892| r892_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : +# 892| m892_2(__va_list_tag[1]) = Uninitialized[args2] : &:r892_1 +# 893| r893_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : +# 893| r893_2(__va_list_tag *) = Convert : r893_1 +# 893| r893_3(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 893| r893_4(__va_list_tag *) = Convert : r893_3 +# 893| v893_5(void) = VarArgsStart : 0:r893_2, 1:r893_4 +# 894| r894_1(glval) = VariableAddress[d] : +# 894| r894_2(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 894| r894_3(__va_list_tag *) = Convert : r894_2 +# 894| r894_4(glval) = VarArg : 0:r894_3 +# 894| r894_5(double) = Load : &:r894_4, ~m888_2 +# 894| m894_6(double) = Store : &:r894_1, r894_5 +# 895| r895_1(glval) = VariableAddress[f] : +# 895| r895_2(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 895| r895_3(__va_list_tag *) = Convert : r895_2 +# 895| r895_4(glval) = VarArg : 0:r895_3 +# 895| r895_5(double) = Load : &:r895_4, ~m888_2 +# 895| r895_6(float) = Convert : r895_5 +# 895| m895_7(float) = Store : &:r895_1, r895_6 +# 896| r896_1(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 896| r896_2(__va_list_tag *) = Convert : r896_1 +# 896| v896_3(void) = VarArgsEnd : 0:r896_2 +# 897| r897_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : +# 897| r897_2(__va_list_tag *) = Convert : r897_1 +# 897| v897_3(void) = VarArgsEnd : 0:r897_2 +# 898| v898_1(void) = NoOp : +# 888| v888_6(void) = ReturnVoid : +# 888| v888_7(void) = UnmodeledUse : mu* +# 888| v888_8(void) = AliasedUse : ~m888_2 +# 888| v888_9(void) = ExitFunction : + +# 900| void CastToVoid(int) +# 900| Block 0 +# 900| v900_1(void) = EnterFunction : +# 900| m900_2(unknown) = AliasedDefinition : +# 900| mu900_3(unknown) = UnmodeledDefinition : +# 900| r900_4(glval) = VariableAddress[x] : +# 900| m900_5(int) = InitializeParameter[x] : &:r900_4 +# 901| r901_1(glval) = VariableAddress[x] : +# 901| v901_2(void) = Convert : r901_1 +# 902| v902_1(void) = NoOp : +# 900| v900_6(void) = ReturnVoid : +# 900| v900_7(void) = UnmodeledUse : mu* +# 900| v900_8(void) = AliasedUse : ~m900_2 +# 900| v900_9(void) = ExitFunction : + +# 904| void ConstantConditions(int) +# 904| Block 0 +# 904| v904_1(void) = EnterFunction : +# 904| m904_2(unknown) = AliasedDefinition : +# 904| mu904_3(unknown) = UnmodeledDefinition : +# 904| r904_4(glval) = VariableAddress[x] : +# 904| m904_5(int) = InitializeParameter[x] : &:r904_4 +# 905| r905_1(glval) = VariableAddress[a] : +# 905| r905_2(bool) = Constant[1] : +# 905| m905_3(bool) = Store : &:r905_1, r905_2 +# 906| r906_1(glval) = VariableAddress[b] : +# 906| r906_2(bool) = Constant[1] : +# 906| v906_3(void) = ConditionalBranch : r906_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 906| Block 1 +# 906| r906_4(glval) = VariableAddress[x] : +# 906| r906_5(int) = Load : &:r906_4, m904_5 +# 906| r906_6(glval) = VariableAddress[#temp906:11] : +# 906| m906_7(int) = Store : &:r906_6, r906_5 +# 906| r906_8(glval) = VariableAddress[#temp906:11] : +# 906| r906_9(int) = Load : &:r906_8, m906_7 +# 906| m906_10(int) = Store : &:r906_1, r906_9 +# 907| v907_1(void) = NoOp : +# 904| v904_6(void) = ReturnVoid : +# 904| v904_7(void) = UnmodeledUse : mu* +# 904| v904_8(void) = AliasedUse : ~m904_2 +# 904| v904_9(void) = ExitFunction : + +# 904| Block 2 +# 904| v904_10(void) = Unreached : + +# 940| void OperatorNew() +# 940| Block 0 +# 940| v940_1(void) = EnterFunction : +# 940| m940_2(unknown) = AliasedDefinition : +# 940| mu940_3(unknown) = UnmodeledDefinition : +# 941| r941_1(glval) = FunctionAddress[operator new] : +# 941| r941_2(unsigned long) = Constant[4] : +# 941| r941_3(void *) = Call : func:r941_1, 0:r941_2 +# 941| m941_4(unknown) = ^CallSideEffect : ~m940_2 +# 941| m941_5(unknown) = Chi : total:m940_2, partial:m941_4 +# 941| r941_6(int *) = Convert : r941_3 +# 942| r942_1(glval) = FunctionAddress[operator new] : +# 942| r942_2(unsigned long) = Constant[4] : +# 942| r942_3(float) = Constant[1.0] : +# 942| r942_4(void *) = Call : func:r942_1, 0:r942_2, 1:r942_3 +# 942| m942_5(unknown) = ^CallSideEffect : ~m941_5 +# 942| m942_6(unknown) = Chi : total:m941_5, partial:m942_5 +# 942| r942_7(int *) = Convert : r942_4 +# 943| r943_1(glval) = FunctionAddress[operator new] : +# 943| r943_2(unsigned long) = Constant[4] : +# 943| r943_3(void *) = Call : func:r943_1, 0:r943_2 +# 943| m943_4(unknown) = ^CallSideEffect : ~m942_6 +# 943| m943_5(unknown) = Chi : total:m942_6, partial:m943_4 +# 943| r943_6(int *) = Convert : r943_3 +# 943| r943_7(int) = Constant[0] : +# 943| m943_8(int) = Store : &:r943_6, r943_7 +# 943| m943_9(unknown) = Chi : total:m943_5, partial:m943_8 +# 944| r944_1(glval) = FunctionAddress[operator new] : +# 944| r944_2(unsigned long) = Constant[8] : +# 944| r944_3(void *) = Call : func:r944_1, 0:r944_2 +# 944| m944_4(unknown) = ^CallSideEffect : ~m943_9 +# 944| m944_5(unknown) = Chi : total:m943_9, partial:m944_4 +# 944| r944_6(String *) = Convert : r944_3 +# 944| r944_7(glval) = FunctionAddress[String] : +# 944| v944_8(void) = Call : func:r944_7, this:r944_6 +# 944| m944_9(unknown) = ^CallSideEffect : ~m944_5 +# 944| m944_10(unknown) = Chi : total:m944_5, partial:m944_9 +# 944| m944_11(String) = ^IndirectMayWriteSideEffect[-1] : &:r944_6 +# 944| m944_12(unknown) = Chi : total:m944_10, partial:m944_11 +# 945| r945_1(glval) = FunctionAddress[operator new] : +# 945| r945_2(unsigned long) = Constant[8] : +# 945| r945_3(float) = Constant[1.0] : +# 945| r945_4(void *) = Call : func:r945_1, 0:r945_2, 1:r945_3 +# 945| m945_5(unknown) = ^CallSideEffect : ~m944_12 +# 945| m945_6(unknown) = Chi : total:m944_12, partial:m945_5 +# 945| r945_7(String *) = Convert : r945_4 +# 945| r945_8(glval) = FunctionAddress[String] : +# 945| r945_9(glval) = StringConstant["hello"] : +# 945| r945_10(char *) = Convert : r945_9 +# 945| v945_11(void) = Call : func:r945_8, this:r945_7, 0:r945_10 +# 945| m945_12(unknown) = ^CallSideEffect : ~m945_6 +# 945| m945_13(unknown) = Chi : total:m945_6, partial:m945_12 +# 945| m945_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r945_7 +# 945| m945_15(unknown) = Chi : total:m945_13, partial:m945_14 +# 945| v945_16(void) = ^BufferReadSideEffect[0] : &:r945_10, ~m940_2 +# 945| m945_17(unknown) = ^BufferMayWriteSideEffect[0] : &:r945_10 +# 945| m945_18(unknown) = Chi : total:m945_15, partial:m945_17 +# 946| r946_1(glval) = FunctionAddress[operator new] : +# 946| r946_2(unsigned long) = Constant[256] : +# 946| r946_3(align_val_t) = Constant[128] : +# 946| r946_4(void *) = Call : func:r946_1, 0:r946_2, 1:r946_3 +# 946| m946_5(unknown) = ^CallSideEffect : ~m945_18 +# 946| m946_6(unknown) = Chi : total:m945_18, partial:m946_5 +# 946| r946_7(Overaligned *) = Convert : r946_4 +# 947| r947_1(glval) = FunctionAddress[operator new] : +# 947| r947_2(unsigned long) = Constant[256] : +# 947| r947_3(align_val_t) = Constant[128] : +# 947| r947_4(float) = Constant[1.0] : +# 947| r947_5(void *) = Call : func:r947_1, 0:r947_2, 1:r947_3, 2:r947_4 +# 947| m947_6(unknown) = ^CallSideEffect : ~m946_6 +# 947| m947_7(unknown) = Chi : total:m946_6, partial:m947_6 +# 947| r947_8(Overaligned *) = Convert : r947_5 +# 947| r947_9(Overaligned) = Constant[0] : +# 947| m947_10(Overaligned) = Store : &:r947_8, r947_9 +# 947| m947_11(unknown) = Chi : total:m947_7, partial:m947_10 +# 948| v948_1(void) = NoOp : +# 940| v940_4(void) = ReturnVoid : +# 940| v940_5(void) = UnmodeledUse : mu* +# 940| v940_6(void) = AliasedUse : ~m947_11 +# 940| v940_7(void) = ExitFunction : + +# 950| void OperatorNewArray(int) +# 950| Block 0 +# 950| v950_1(void) = EnterFunction : +# 950| m950_2(unknown) = AliasedDefinition : +# 950| mu950_3(unknown) = UnmodeledDefinition : +# 950| r950_4(glval) = VariableAddress[n] : +# 950| m950_5(int) = InitializeParameter[n] : &:r950_4 +# 951| r951_1(glval) = FunctionAddress[operator new[]] : +# 951| r951_2(unsigned long) = Constant[40] : +# 951| r951_3(void *) = Call : func:r951_1, 0:r951_2 +# 951| m951_4(unknown) = ^CallSideEffect : ~m950_2 +# 951| m951_5(unknown) = Chi : total:m950_2, partial:m951_4 +# 951| r951_6(int *) = Convert : r951_3 +# 952| r952_1(glval) = FunctionAddress[operator new[]] : +# 952| r952_2(glval) = VariableAddress[n] : +# 952| r952_3(int) = Load : &:r952_2, m950_5 +# 952| r952_4(unsigned long) = Convert : r952_3 +# 952| r952_5(unsigned long) = Constant[4] : +# 952| r952_6(unsigned long) = Mul : r952_4, r952_5 +# 952| r952_7(void *) = Call : func:r952_1, 0:r952_6 +# 952| m952_8(unknown) = ^CallSideEffect : ~m951_5 +# 952| m952_9(unknown) = Chi : total:m951_5, partial:m952_8 +# 952| r952_10(int *) = Convert : r952_7 +# 953| r953_1(glval) = FunctionAddress[operator new[]] : +# 953| r953_2(glval) = VariableAddress[n] : +# 953| r953_3(int) = Load : &:r953_2, m950_5 +# 953| r953_4(unsigned long) = Convert : r953_3 +# 953| r953_5(unsigned long) = Constant[4] : +# 953| r953_6(unsigned long) = Mul : r953_4, r953_5 +# 953| r953_7(float) = Constant[1.0] : +# 953| r953_8(void *) = Call : func:r953_1, 0:r953_6, 1:r953_7 +# 953| m953_9(unknown) = ^CallSideEffect : ~m952_9 +# 953| m953_10(unknown) = Chi : total:m952_9, partial:m953_9 +# 953| r953_11(int *) = Convert : r953_8 +# 954| r954_1(glval) = FunctionAddress[operator new[]] : +# 954| r954_2(glval) = VariableAddress[n] : +# 954| r954_3(int) = Load : &:r954_2, m950_5 +# 954| r954_4(unsigned long) = Convert : r954_3 +# 954| r954_5(unsigned long) = Constant[8] : +# 954| r954_6(unsigned long) = Mul : r954_4, r954_5 +# 954| r954_7(void *) = Call : func:r954_1, 0:r954_6 +# 954| m954_8(unknown) = ^CallSideEffect : ~m953_10 +# 954| m954_9(unknown) = Chi : total:m953_10, partial:m954_8 +# 954| r954_10(String *) = Convert : r954_7 +# 955| r955_1(glval) = FunctionAddress[operator new[]] : +# 955| r955_2(glval) = VariableAddress[n] : +# 955| r955_3(int) = Load : &:r955_2, m950_5 +# 955| r955_4(unsigned long) = Convert : r955_3 +# 955| r955_5(unsigned long) = Constant[256] : +# 955| r955_6(unsigned long) = Mul : r955_4, r955_5 +# 955| r955_7(align_val_t) = Constant[128] : +# 955| r955_8(void *) = Call : func:r955_1, 0:r955_6, 1:r955_7 +# 955| m955_9(unknown) = ^CallSideEffect : ~m954_9 +# 955| m955_10(unknown) = Chi : total:m954_9, partial:m955_9 +# 955| r955_11(Overaligned *) = Convert : r955_8 +# 956| r956_1(glval) = FunctionAddress[operator new[]] : +# 956| r956_2(unsigned long) = Constant[2560] : +# 956| r956_3(align_val_t) = Constant[128] : +# 956| r956_4(float) = Constant[1.0] : +# 956| r956_5(void *) = Call : func:r956_1, 0:r956_2, 1:r956_3, 2:r956_4 +# 956| m956_6(unknown) = ^CallSideEffect : ~m955_10 +# 956| m956_7(unknown) = Chi : total:m955_10, partial:m956_6 +# 956| r956_8(Overaligned *) = Convert : r956_5 +# 957| r957_1(glval) = FunctionAddress[operator new[]] : +# 957| r957_2(glval) = VariableAddress[n] : +# 957| r957_3(int) = Load : &:r957_2, m950_5 +# 957| r957_4(unsigned long) = Convert : r957_3 +# 957| r957_5(unsigned long) = Constant[1] : +# 957| r957_6(unsigned long) = Mul : r957_4, r957_5 +# 957| r957_7(void *) = Call : func:r957_1, 0:r957_6 +# 957| m957_8(unknown) = ^CallSideEffect : ~m956_7 +# 957| m957_9(unknown) = Chi : total:m956_7, partial:m957_8 +# 957| r957_10(DefaultCtorWithDefaultParam *) = Convert : r957_7 +# 958| r958_1(glval) = FunctionAddress[operator new[]] : +# 958| r958_2(glval) = VariableAddress[n] : +# 958| r958_3(int) = Load : &:r958_2, m950_5 +# 958| r958_4(unsigned long) = Convert : r958_3 +# 958| r958_5(unsigned long) = Constant[4] : +# 958| r958_6(unsigned long) = Mul : r958_4, r958_5 +# 958| r958_7(void *) = Call : func:r958_1, 0:r958_6 +# 958| m958_8(unknown) = ^CallSideEffect : ~m957_9 +# 958| m958_9(unknown) = Chi : total:m957_9, partial:m958_8 +# 958| r958_10(int *) = Convert : r958_7 +# 959| v959_1(void) = NoOp : +# 950| v950_6(void) = ReturnVoid : +# 950| v950_7(void) = UnmodeledUse : mu* +# 950| v950_8(void) = AliasedUse : ~m958_9 +# 950| v950_9(void) = ExitFunction : + +# 961| int designatedInit() +# 961| Block 0 +# 961| v961_1(void) = EnterFunction : +# 961| m961_2(unknown) = AliasedDefinition : +# 961| mu961_3(unknown) = UnmodeledDefinition : +# 962| r962_1(glval) = VariableAddress[a1] : +# 962| m962_2(int[1000]) = Uninitialized[a1] : &:r962_1 +# 962| r962_3(int) = Constant[0] : +# 962| r962_4(glval) = PointerAdd[4] : r962_1, r962_3 +# 962| r962_5(unknown[8]) = Constant[0] : +# 962| m962_6(unknown[8]) = Store : &:r962_4, r962_5 +# 962| m962_7(int[1000]) = Chi : total:m962_2, partial:m962_6 +# 962| r962_8(int) = Constant[2] : +# 962| r962_9(glval) = PointerAdd[4] : r962_1, r962_8 +# 962| r962_10(int) = Constant[10002] : +# 962| m962_11(int) = Store : &:r962_9, r962_10 +# 962| m962_12(int[1000]) = Chi : total:m962_7, partial:m962_11 +# 962| r962_13(int) = Constant[3] : +# 962| r962_14(glval) = PointerAdd[4] : r962_1, r962_13 +# 962| r962_15(unknown[3588]) = Constant[0] : +# 962| m962_16(unknown[3588]) = Store : &:r962_14, r962_15 +# 962| m962_17(int[1000]) = Chi : total:m962_12, partial:m962_16 +# 962| r962_18(int) = Constant[900] : +# 962| r962_19(glval) = PointerAdd[4] : r962_1, r962_18 +# 962| r962_20(int) = Constant[10900] : +# 962| m962_21(int) = Store : &:r962_19, r962_20 +# 962| m962_22(int[1000]) = Chi : total:m962_17, partial:m962_21 +# 962| r962_23(int) = Constant[901] : +# 962| r962_24(glval) = PointerAdd[4] : r962_1, r962_23 +# 962| r962_25(unknown[396]) = Constant[0] : +# 962| m962_26(unknown[396]) = Store : &:r962_24, r962_25 +# 962| m962_27(int[1000]) = Chi : total:m962_22, partial:m962_26 +# 963| r963_1(glval) = VariableAddress[#return] : +# 963| r963_2(glval) = VariableAddress[a1] : +# 963| r963_3(int *) = Convert : r963_2 +# 963| r963_4(int) = Constant[900] : +# 963| r963_5(glval) = PointerAdd[4] : r963_3, r963_4 +# 963| r963_6(int) = Load : &:r963_5, m962_21 +# 963| m963_7(int) = Store : &:r963_1, r963_6 +# 961| r961_4(glval) = VariableAddress[#return] : +# 961| v961_5(void) = ReturnValue : &:r961_4, m963_7 +# 961| v961_6(void) = UnmodeledUse : mu* +# 961| v961_7(void) = AliasedUse : ~m961_2 +# 961| v961_8(void) = ExitFunction : + +# 966| void IfStmtWithDeclaration(int, int) +# 966| Block 0 +# 966| v966_1(void) = EnterFunction : +# 966| m966_2(unknown) = AliasedDefinition : +# 966| mu966_3(unknown) = UnmodeledDefinition : +# 966| r966_4(glval) = VariableAddress[x] : +# 966| m966_5(int) = InitializeParameter[x] : &:r966_4 +# 966| r966_6(glval) = VariableAddress[y] : +# 966| m966_7(int) = InitializeParameter[y] : &:r966_6 +# 967| r967_1(glval) = VariableAddress[b] : +# 967| r967_2(glval) = VariableAddress[x] : +# 967| r967_3(int) = Load : &:r967_2, m966_5 +# 967| r967_4(glval) = VariableAddress[y] : +# 967| r967_5(int) = Load : &:r967_4, m966_7 +# 967| r967_6(bool) = CompareLT : r967_3, r967_5 +# 967| m967_7(bool) = Store : &:r967_1, r967_6 +# 967| r967_8(glval) = VariableAddress[b] : +# 967| r967_9(bool) = Load : &:r967_8, m967_7 +# 967| r967_10(bool) = CopyValue : r967_9 +# 967| v967_11(void) = ConditionalBranch : r967_10 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 968| Block 1 +# 968| r968_1(int) = Constant[5] : +# 968| r968_2(glval) = VariableAddress[x] : +# 968| m968_3(int) = Store : &:r968_2, r968_1 +#-----| Goto -> Block 6 + +# 970| Block 2 +# 970| r970_1(glval) = VariableAddress[z] : +# 970| r970_2(glval) = VariableAddress[x] : +# 970| r970_3(int) = Load : &:r970_2, m966_5 +# 970| r970_4(glval) = VariableAddress[y] : +# 970| r970_5(int) = Load : &:r970_4, m966_7 +# 970| r970_6(int) = Add : r970_3, r970_5 +# 970| m970_7(int) = Store : &:r970_1, r970_6 +# 970| r970_8(glval) = VariableAddress[z] : +# 970| r970_9(int) = Load : &:r970_8, m970_7 +# 970| r970_10(int) = Constant[0] : +# 970| r970_11(bool) = CompareNE : r970_9, r970_10 +# 970| r970_12(bool) = CopyValue : r970_11 +# 970| v970_13(void) = ConditionalBranch : r970_12 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 971| Block 3 +# 971| r971_1(int) = Constant[7] : +# 971| r971_2(glval) = VariableAddress[y] : +# 971| m971_3(int) = Store : &:r971_2, r971_1 +#-----| Goto -> Block 6 + +# 973| Block 4 +# 973| r973_1(glval) = VariableAddress[p] : +# 973| r973_2(glval) = VariableAddress[x] : +# 973| r973_3(int *) = CopyValue : r973_2 +# 973| m973_4(int *) = Store : &:r973_1, r973_3 +# 973| r973_5(glval) = VariableAddress[p] : +# 973| r973_6(int *) = Load : &:r973_5, m973_4 +# 973| r973_7(int *) = Constant[0] : +# 973| r973_8(bool) = CompareNE : r973_6, r973_7 +# 973| r973_9(bool) = CopyValue : r973_8 +# 973| v973_10(void) = ConditionalBranch : r973_9 +#-----| False -> Block 6 +#-----| True -> Block 5 + +# 974| Block 5 +# 974| r974_1(int) = Constant[2] : +# 974| r974_2(glval) = VariableAddress[p] : +# 974| r974_3(int *) = Load : &:r974_2, m973_4 +# 974| r974_4(glval) = CopyValue : r974_3 +# 974| m974_5(int) = Store : &:r974_4, r974_1 +#-----| Goto -> Block 6 + +# 976| Block 6 +# 976| v976_1(void) = NoOp : +# 966| v966_8(void) = ReturnVoid : +# 966| v966_9(void) = UnmodeledUse : mu* +# 966| v966_10(void) = AliasedUse : ~m966_2 +# 966| v966_11(void) = ExitFunction : + +# 978| void WhileStmtWithDeclaration(int, int) +# 978| Block 0 +# 978| v978_1(void) = EnterFunction : +# 978| m978_2(unknown) = AliasedDefinition : +# 978| mu978_3(unknown) = UnmodeledDefinition : +# 978| r978_4(glval) = VariableAddress[x] : +# 978| m978_5(int) = InitializeParameter[x] : &:r978_4 +# 978| r978_6(glval) = VariableAddress[y] : +# 978| m978_7(int) = InitializeParameter[y] : &:r978_6 +#-----| Goto -> Block 7 + +# 979| Block 1 +# 979| v979_1(void) = NoOp : +#-----| Goto (back edge) -> Block 7 + +# 981| Block 2 +# 981| r981_1(glval) = VariableAddress[z] : +# 981| r981_2(glval) = VariableAddress[x] : +# 981| r981_3(int) = Load : &:r981_2, m978_5 +# 981| r981_4(glval) = VariableAddress[y] : +# 981| r981_5(int) = Load : &:r981_4, m978_7 +# 981| r981_6(int) = Add : r981_3, r981_5 +# 981| m981_7(int) = Store : &:r981_1, r981_6 +# 981| r981_8(glval) = VariableAddress[z] : +# 981| r981_9(int) = Load : &:r981_8, m981_7 +# 981| r981_10(int) = Constant[0] : +# 981| r981_11(bool) = CompareNE : r981_9, r981_10 +# 981| r981_12(bool) = CopyValue : r981_11 +# 981| v981_13(void) = ConditionalBranch : r981_12 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 981| Block 3 +# 981| v981_14(void) = NoOp : +#-----| Goto (back edge) -> Block 2 + +# 983| Block 4 +# 983| r983_1(glval) = VariableAddress[p] : +# 983| r983_2(glval) = VariableAddress[x] : +# 983| r983_3(int *) = CopyValue : r983_2 +# 983| m983_4(int *) = Store : &:r983_1, r983_3 +# 983| r983_5(glval) = VariableAddress[p] : +# 983| r983_6(int *) = Load : &:r983_5, m983_4 +# 983| r983_7(int *) = Constant[0] : +# 983| r983_8(bool) = CompareNE : r983_6, r983_7 +# 983| r983_9(bool) = CopyValue : r983_8 +# 983| v983_10(void) = ConditionalBranch : r983_9 +#-----| False -> Block 6 +#-----| True -> Block 5 + +# 983| Block 5 +# 983| v983_11(void) = NoOp : +#-----| Goto (back edge) -> Block 4 + +# 985| Block 6 +# 985| v985_1(void) = NoOp : +# 978| v978_8(void) = ReturnVoid : +# 978| v978_9(void) = UnmodeledUse : mu* +# 978| v978_10(void) = AliasedUse : ~m978_2 +# 978| v978_11(void) = ExitFunction : + +# 979| Block 7 +# 979| r979_2(glval) = VariableAddress[b] : +# 979| r979_3(glval) = VariableAddress[x] : +# 979| r979_4(int) = Load : &:r979_3, m978_5 +# 979| r979_5(glval) = VariableAddress[y] : +# 979| r979_6(int) = Load : &:r979_5, m978_7 +# 979| r979_7(bool) = CompareLT : r979_4, r979_6 +# 979| m979_8(bool) = Store : &:r979_2, r979_7 +# 979| r979_9(glval) = VariableAddress[b] : +# 979| r979_10(bool) = Load : &:r979_9, m979_8 +# 979| r979_11(bool) = CopyValue : r979_10 +# 979| v979_12(void) = ConditionalBranch : r979_11 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 987| int PointerDecay(int[], int(float)) +# 987| Block 0 +# 987| v987_1(void) = EnterFunction : +# 987| m987_2(unknown) = AliasedDefinition : +# 987| mu987_3(unknown) = UnmodeledDefinition : +# 987| r987_4(glval) = VariableAddress[a] : +# 987| m987_5(int *) = InitializeParameter[a] : &:r987_4 +# 987| r987_6(int *) = Load : &:r987_4, m987_5 +# 987| m987_7(unknown) = InitializeIndirection[a] : &:r987_6 +# 987| m987_8(unknown) = Chi : total:m987_2, partial:m987_7 +# 987| r987_9(glval<..(*)(..)>) = VariableAddress[fn] : +# 987| m987_10(..(*)(..)) = InitializeParameter[fn] : &:r987_9 +# 988| r988_1(glval) = VariableAddress[#return] : +# 988| r988_2(glval) = VariableAddress[a] : +# 988| r988_3(int *) = Load : &:r988_2, m987_5 +# 988| r988_4(int) = Constant[0] : +# 988| r988_5(glval) = PointerAdd[4] : r988_3, r988_4 +# 988| r988_6(int) = Load : &:r988_5, ~m987_8 +# 988| r988_7(glval<..(*)(..)>) = VariableAddress[fn] : +# 988| r988_8(..(*)(..)) = Load : &:r988_7, m987_10 +# 988| r988_9(float) = Constant[1.0] : +# 988| r988_10(int) = Call : func:r988_8, 0:r988_9 +# 988| m988_11(unknown) = ^CallSideEffect : ~m987_8 +# 988| m988_12(unknown) = Chi : total:m987_8, partial:m988_11 +# 988| r988_13(int) = Add : r988_6, r988_10 +# 988| m988_14(int) = Store : &:r988_1, r988_13 +# 987| v987_11(void) = ReturnIndirection : &:r987_6, ~m988_12 +# 987| r987_12(glval) = VariableAddress[#return] : +# 987| v987_13(void) = ReturnValue : &:r987_12, m988_14 +# 987| v987_14(void) = UnmodeledUse : mu* +# 987| v987_15(void) = AliasedUse : ~m988_12 +# 987| v987_16(void) = ExitFunction : + +# 991| int ExprStmt(int, int, int) +# 991| Block 0 +# 991| v991_1(void) = EnterFunction : +# 991| m991_2(unknown) = AliasedDefinition : +# 991| mu991_3(unknown) = UnmodeledDefinition : +# 991| r991_4(glval) = VariableAddress[b] : +# 991| m991_5(int) = InitializeParameter[b] : &:r991_4 +# 991| r991_6(glval) = VariableAddress[y] : +# 991| m991_7(int) = InitializeParameter[y] : &:r991_6 +# 991| r991_8(glval) = VariableAddress[z] : +# 991| m991_9(int) = InitializeParameter[z] : &:r991_8 +# 992| r992_1(glval) = VariableAddress[x] : +# 993| r993_1(glval) = VariableAddress[w] : +# 993| m993_2(int) = Uninitialized[w] : &:r993_1 +# 994| r994_1(glval) = VariableAddress[b] : +# 994| r994_2(int) = Load : &:r994_1, m991_5 +# 994| r994_3(int) = Constant[0] : +# 994| r994_4(bool) = CompareNE : r994_2, r994_3 +# 994| v994_5(void) = ConditionalBranch : r994_4 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 995| Block 1 +# 995| r995_1(glval) = VariableAddress[y] : +# 995| r995_2(int) = Load : &:r995_1, m991_7 +# 995| r995_3(glval) = VariableAddress[w] : +# 995| m995_4(int) = Store : &:r995_3, r995_2 +#-----| Goto -> Block 3 + +# 997| Block 2 +# 997| r997_1(glval) = VariableAddress[z] : +# 997| r997_2(int) = Load : &:r997_1, m991_9 +# 997| r997_3(glval) = VariableAddress[w] : +# 997| m997_4(int) = Store : &:r997_3, r997_2 +#-----| Goto -> Block 3 + +# 999| Block 3 +# 999| m999_1(int) = Phi : from 1:m995_4, from 2:m997_4 +# 999| r999_2(glval) = VariableAddress[w] : +# 999| r999_3(int) = Load : &:r999_2, m999_1 +# 992| r992_2(int) = CopyValue : r999_3 +# 992| m992_3(int) = Store : &:r992_1, r992_2 +# 1002| r1002_1(glval) = VariableAddress[#return] : +# 1002| r1002_2(glval) = VariableAddress[x] : +# 1002| r1002_3(int) = Load : &:r1002_2, m992_3 +# 1002| r1002_4(int) = CopyValue : r1002_3 +# 1002| m1002_5(int) = Store : &:r1002_1, r1002_4 +# 991| r991_10(glval) = VariableAddress[#return] : +# 991| v991_11(void) = ReturnValue : &:r991_10, m1002_5 +# 991| v991_12(void) = UnmodeledUse : mu* +# 991| v991_13(void) = AliasedUse : ~m991_2 +# 991| v991_14(void) = ExitFunction : + +# 1006| void OperatorDelete() +# 1006| Block 0 +# 1006| v1006_1(void) = EnterFunction : +# 1006| m1006_2(unknown) = AliasedDefinition : +# 1006| mu1006_3(unknown) = UnmodeledDefinition : +# 1007| r1007_1(int *) = Constant[0] : +# 1007| v1007_2(void) = NoOp : +# 1008| r1008_1(String *) = Constant[0] : +# 1008| v1008_2(void) = NoOp : +# 1009| r1009_1(SizedDealloc *) = Constant[0] : +# 1009| v1009_2(void) = NoOp : +# 1010| r1010_1(Overaligned *) = Constant[0] : +# 1010| v1010_2(void) = NoOp : +# 1011| r1011_1(PolymorphicBase *) = Constant[0] : +# 1011| v1011_2(void) = NoOp : +# 1012| v1012_1(void) = NoOp : +# 1006| v1006_4(void) = ReturnVoid : +# 1006| v1006_5(void) = UnmodeledUse : mu* +# 1006| v1006_6(void) = AliasedUse : ~m1006_2 +# 1006| v1006_7(void) = ExitFunction : + +# 1015| void OperatorDeleteArray() +# 1015| Block 0 +# 1015| v1015_1(void) = EnterFunction : +# 1015| m1015_2(unknown) = AliasedDefinition : +# 1015| mu1015_3(unknown) = UnmodeledDefinition : +# 1016| r1016_1(int *) = Constant[0] : +# 1016| v1016_2(void) = NoOp : +# 1017| r1017_1(String *) = Constant[0] : +# 1017| v1017_2(void) = NoOp : +# 1018| r1018_1(SizedDealloc *) = Constant[0] : +# 1018| v1018_2(void) = NoOp : +# 1019| r1019_1(Overaligned *) = Constant[0] : +# 1019| v1019_2(void) = NoOp : +# 1020| r1020_1(PolymorphicBase *) = Constant[0] : +# 1020| v1020_2(void) = NoOp : +# 1021| v1021_1(void) = NoOp : +# 1015| v1015_4(void) = ReturnVoid : +# 1015| v1015_5(void) = UnmodeledUse : mu* +# 1015| v1015_6(void) = AliasedUse : ~m1015_2 +# 1015| v1015_7(void) = ExitFunction : + +# 1025| void EmptyStructInit() +# 1025| Block 0 +# 1025| v1025_1(void) = EnterFunction : +# 1025| m1025_2(unknown) = AliasedDefinition : +# 1025| mu1025_3(unknown) = UnmodeledDefinition : +# 1026| r1026_1(glval) = VariableAddress[s] : +# 1026| m1026_2(EmptyStruct) = Uninitialized[s] : &:r1026_1 +# 1027| v1027_1(void) = NoOp : +# 1025| v1025_4(void) = ReturnVoid : +# 1025| v1025_5(void) = UnmodeledUse : mu* +# 1025| v1025_6(void) = AliasedUse : ~m1025_2 +# 1025| v1025_7(void) = ExitFunction : + +# 1029| void (lambda [] type at line 1029, col. 12)::operator()() const +# 1029| Block 0 +# 1029| v1029_1(void) = EnterFunction : +# 1029| m1029_2(unknown) = AliasedDefinition : +# 1029| mu1029_3(unknown) = UnmodeledDefinition : +# 1029| r1029_4(glval) = InitializeThis : +# 1029| v1029_5(void) = NoOp : +# 1029| v1029_6(void) = ReturnVoid : +# 1029| v1029_7(void) = UnmodeledUse : mu* +# 1029| v1029_8(void) = AliasedUse : ~m1029_2 +# 1029| v1029_9(void) = ExitFunction : + +# 1029| void(* (lambda [] type at line 1029, col. 12)::operator void (*)()() const)() +# 1029| Block 0 +# 1029| v1029_1(void) = EnterFunction : +# 1029| m1029_2(unknown) = AliasedDefinition : +# 1029| mu1029_3(unknown) = UnmodeledDefinition : +# 1029| r1029_4(glval) = InitializeThis : +# 1029| r1029_5(glval<..(*)(..)>) = VariableAddress[#return] : +# 1029| r1029_6(..(*)(..)) = FunctionAddress[_FUN] : +# 1029| m1029_7(..(*)(..)) = Store : &:r1029_5, r1029_6 +# 1029| r1029_8(glval<..(*)(..)>) = VariableAddress[#return] : +# 1029| v1029_9(void) = ReturnValue : &:r1029_8, m1029_7 +# 1029| v1029_10(void) = UnmodeledUse : mu* +# 1029| v1029_11(void) = AliasedUse : ~m1029_2 +# 1029| v1029_12(void) = ExitFunction : + +# 1031| void Lambda(int, String const&) +# 1031| Block 0 +# 1031| v1031_1(void) = EnterFunction : +# 1031| m1031_2(unknown) = AliasedDefinition : +# 1031| mu1031_3(unknown) = UnmodeledDefinition : +# 1031| r1031_4(glval) = VariableAddress[x] : +# 1031| m1031_5(int) = InitializeParameter[x] : &:r1031_4 +# 1031| r1031_6(glval) = VariableAddress[s] : +# 1031| m1031_7(String &) = InitializeParameter[s] : &:r1031_6 +# 1031| r1031_8(String &) = Load : &:r1031_6, m1031_7 +# 1031| m1031_9(unknown) = InitializeIndirection[s] : &:r1031_8 +# 1031| m1031_10(unknown) = Chi : total:m1031_2, partial:m1031_9 +# 1032| r1032_1(glval) = VariableAddress[lambda_empty] : +# 1032| r1032_2(glval) = VariableAddress[#temp1032:23] : +# 1032| m1032_3(decltype([...](...){...})) = Uninitialized[#temp1032:23] : &:r1032_2 +# 1032| r1032_4(decltype([...](...){...})) = Load : &:r1032_2, m1032_3 +# 1032| m1032_5(decltype([...](...){...})) = Store : &:r1032_1, r1032_4 +# 1033| r1033_1(char) = Constant[65] : +# 1034| r1034_1(glval) = VariableAddress[lambda_ref] : +# 1034| r1034_2(glval) = VariableAddress[#temp1034:20] : +# 1034| m1034_3(decltype([...](...){...})) = Uninitialized[#temp1034:20] : &:r1034_2 +# 1034| r1034_4(glval) = FieldAddress[s] : r1034_2 +#-----| r0_1(glval) = VariableAddress[s] : +#-----| r0_2(String &) = Load : &:r0_1, m1031_7 +# 1034| r1034_5(glval) = CopyValue : r0_2 +# 1034| r1034_6(String &) = CopyValue : r1034_5 +# 1034| m1034_7(String &) = Store : &:r1034_4, r1034_6 +# 1034| m1034_8(decltype([...](...){...})) = Chi : total:m1034_3, partial:m1034_7 +# 1034| r1034_9(glval) = FieldAddress[x] : r1034_2 +#-----| r0_3(glval) = VariableAddress[x] : +#-----| r0_4(int &) = CopyValue : r0_3 +#-----| m0_5(int &) = Store : &:r1034_9, r0_4 +#-----| m0_6(decltype([...](...){...})) = Chi : total:m1034_8, partial:m0_5 +# 1034| r1034_10(decltype([...](...){...})) = Load : &:r1034_2, ~m0_6 +# 1034| m1034_11(decltype([...](...){...})) = Store : &:r1034_1, r1034_10 +# 1035| r1035_1(glval) = VariableAddress[lambda_ref] : +# 1035| r1035_2(glval) = Convert : r1035_1 +# 1035| r1035_3(glval) = FunctionAddress[operator()] : +# 1035| r1035_4(float) = Constant[1.0] : +# 1035| r1035_5(char) = Call : func:r1035_3, this:r1035_2, 0:r1035_4 +# 1035| m1035_6(unknown) = ^CallSideEffect : ~m1031_10 +# 1035| m1035_7(unknown) = Chi : total:m1031_10, partial:m1035_6 +# 1035| v1035_8(void) = ^BufferReadSideEffect[-1] : &:r1035_2, ~m1034_11 +# 1035| m1035_9(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1035_2 +# 1035| m1035_10(decltype([...](...){...})) = Chi : total:m1034_11, partial:m1035_9 +# 1036| r1036_1(glval) = VariableAddress[lambda_val] : +# 1036| r1036_2(glval) = VariableAddress[#temp1036:20] : +# 1036| m1036_3(decltype([...](...){...})) = Uninitialized[#temp1036:20] : &:r1036_2 +# 1036| r1036_4(glval) = FieldAddress[s] : r1036_2 +#-----| r0_7(glval) = FunctionAddress[String] : +#-----| v0_8(void) = Call : func:r0_7, this:r1036_4 +#-----| m0_9(unknown) = ^CallSideEffect : ~m1035_7 +#-----| m0_10(unknown) = Chi : total:m1035_7, partial:m0_9 +#-----| m0_11(String) = ^IndirectMayWriteSideEffect[-1] : &:r1036_4 +#-----| m0_12(decltype([...](...){...})) = Chi : total:m1036_3, partial:m0_11 +# 1036| r1036_5(glval) = FieldAddress[x] : r1036_2 +#-----| r0_13(glval) = VariableAddress[x] : +#-----| r0_14(int) = Load : &:r0_13, m1031_5 +#-----| m0_15(int) = Store : &:r1036_5, r0_14 +#-----| m0_16(decltype([...](...){...})) = Chi : total:m0_12, partial:m0_15 +# 1036| r1036_6(decltype([...](...){...})) = Load : &:r1036_2, ~m0_16 +# 1036| m1036_7(decltype([...](...){...})) = Store : &:r1036_1, r1036_6 +# 1037| r1037_1(glval) = VariableAddress[lambda_val] : +# 1037| r1037_2(glval) = Convert : r1037_1 +# 1037| r1037_3(glval) = FunctionAddress[operator()] : +# 1037| r1037_4(float) = Constant[2.0] : +# 1037| r1037_5(char) = Call : func:r1037_3, this:r1037_2, 0:r1037_4 +# 1037| m1037_6(unknown) = ^CallSideEffect : ~m0_10 +# 1037| m1037_7(unknown) = Chi : total:m0_10, partial:m1037_6 +# 1037| v1037_8(void) = ^BufferReadSideEffect[-1] : &:r1037_2, ~m1036_7 +# 1037| m1037_9(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1037_2 +# 1037| m1037_10(decltype([...](...){...})) = Chi : total:m1036_7, partial:m1037_9 +# 1038| r1038_1(glval) = VariableAddress[lambda_ref_explicit] : +# 1038| r1038_2(glval) = VariableAddress[#temp1038:29] : +# 1038| m1038_3(decltype([...](...){...})) = Uninitialized[#temp1038:29] : &:r1038_2 +# 1038| r1038_4(glval) = FieldAddress[s] : r1038_2 +# 1038| r1038_5(glval) = VariableAddress[s] : +# 1038| r1038_6(String &) = Load : &:r1038_5, m1031_7 +# 1038| r1038_7(glval) = CopyValue : r1038_6 +# 1038| r1038_8(String &) = CopyValue : r1038_7 +# 1038| m1038_9(String &) = Store : &:r1038_4, r1038_8 +# 1038| r1038_10(decltype([...](...){...})) = Load : &:r1038_2, ~m1038_9 +# 1038| m1038_11(decltype([...](...){...})) = Store : &:r1038_1, r1038_10 +# 1039| r1039_1(glval) = VariableAddress[lambda_ref_explicit] : +# 1039| r1039_2(glval) = Convert : r1039_1 +# 1039| r1039_3(glval) = FunctionAddress[operator()] : +# 1039| r1039_4(float) = Constant[3.0] : +# 1039| r1039_5(char) = Call : func:r1039_3, this:r1039_2, 0:r1039_4 +# 1039| m1039_6(unknown) = ^CallSideEffect : ~m1037_7 +# 1039| m1039_7(unknown) = Chi : total:m1037_7, partial:m1039_6 +# 1039| v1039_8(void) = ^BufferReadSideEffect[-1] : &:r1039_2, ~m1038_11 +# 1039| m1039_9(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1039_2 +# 1039| m1039_10(decltype([...](...){...})) = Chi : total:m1038_11, partial:m1039_9 +# 1040| r1040_1(glval) = VariableAddress[lambda_val_explicit] : +# 1040| r1040_2(glval) = VariableAddress[#temp1040:29] : +# 1040| m1040_3(decltype([...](...){...})) = Uninitialized[#temp1040:29] : &:r1040_2 +# 1040| r1040_4(glval) = FieldAddress[s] : r1040_2 +#-----| r0_17(glval) = FunctionAddress[String] : +#-----| v0_18(void) = Call : func:r0_17, this:r1040_4 +#-----| m0_19(unknown) = ^CallSideEffect : ~m1039_7 +#-----| m0_20(unknown) = Chi : total:m1039_7, partial:m0_19 +#-----| m0_21(String) = ^IndirectMayWriteSideEffect[-1] : &:r1040_4 +#-----| m0_22(decltype([...](...){...})) = Chi : total:m1040_3, partial:m0_21 +# 1040| r1040_5(decltype([...](...){...})) = Load : &:r1040_2, ~m0_22 +# 1040| m1040_6(decltype([...](...){...})) = Store : &:r1040_1, r1040_5 +# 1041| r1041_1(glval) = VariableAddress[lambda_val_explicit] : +# 1041| r1041_2(glval) = Convert : r1041_1 +# 1041| r1041_3(glval) = FunctionAddress[operator()] : +# 1041| r1041_4(float) = Constant[4.0] : +# 1041| r1041_5(char) = Call : func:r1041_3, this:r1041_2, 0:r1041_4 +# 1041| m1041_6(unknown) = ^CallSideEffect : ~m0_20 +# 1041| m1041_7(unknown) = Chi : total:m0_20, partial:m1041_6 +# 1041| v1041_8(void) = ^BufferReadSideEffect[-1] : &:r1041_2, ~m1040_6 +# 1041| m1041_9(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1041_2 +# 1041| m1041_10(decltype([...](...){...})) = Chi : total:m1040_6, partial:m1041_9 +# 1042| r1042_1(glval) = VariableAddress[lambda_mixed_explicit] : +# 1042| r1042_2(glval) = VariableAddress[#temp1042:31] : +# 1042| m1042_3(decltype([...](...){...})) = Uninitialized[#temp1042:31] : &:r1042_2 +# 1042| r1042_4(glval) = FieldAddress[s] : r1042_2 +# 1042| r1042_5(glval) = VariableAddress[s] : +# 1042| r1042_6(String &) = Load : &:r1042_5, m1031_7 +# 1042| r1042_7(glval) = CopyValue : r1042_6 +# 1042| r1042_8(String &) = CopyValue : r1042_7 +# 1042| m1042_9(String &) = Store : &:r1042_4, r1042_8 +# 1042| m1042_10(decltype([...](...){...})) = Chi : total:m1042_3, partial:m1042_9 +# 1042| r1042_11(glval) = FieldAddress[x] : r1042_2 +# 1042| r1042_12(glval) = VariableAddress[x] : +# 1042| r1042_13(int) = Load : &:r1042_12, m1031_5 +# 1042| m1042_14(int) = Store : &:r1042_11, r1042_13 +# 1042| m1042_15(decltype([...](...){...})) = Chi : total:m1042_10, partial:m1042_14 +# 1042| r1042_16(decltype([...](...){...})) = Load : &:r1042_2, ~m1042_15 +# 1042| m1042_17(decltype([...](...){...})) = Store : &:r1042_1, r1042_16 +# 1043| r1043_1(glval) = VariableAddress[lambda_mixed_explicit] : +# 1043| r1043_2(glval) = Convert : r1043_1 +# 1043| r1043_3(glval) = FunctionAddress[operator()] : +# 1043| r1043_4(float) = Constant[5.0] : +# 1043| r1043_5(char) = Call : func:r1043_3, this:r1043_2, 0:r1043_4 +# 1043| m1043_6(unknown) = ^CallSideEffect : ~m1041_7 +# 1043| m1043_7(unknown) = Chi : total:m1041_7, partial:m1043_6 +# 1043| v1043_8(void) = ^BufferReadSideEffect[-1] : &:r1043_2, ~m1042_17 +# 1043| m1043_9(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1043_2 +# 1043| m1043_10(decltype([...](...){...})) = Chi : total:m1042_17, partial:m1043_9 +# 1044| r1044_1(glval) = VariableAddress[r] : +# 1044| r1044_2(glval) = VariableAddress[x] : +# 1044| r1044_3(int) = Load : &:r1044_2, m1031_5 +# 1044| r1044_4(int) = Constant[1] : +# 1044| r1044_5(int) = Sub : r1044_3, r1044_4 +# 1044| m1044_6(int) = Store : &:r1044_1, r1044_5 +# 1045| r1045_1(glval) = VariableAddress[lambda_inits] : +# 1045| r1045_2(glval) = VariableAddress[#temp1045:22] : +# 1045| m1045_3(decltype([...](...){...})) = Uninitialized[#temp1045:22] : &:r1045_2 +# 1045| r1045_4(glval) = FieldAddress[s] : r1045_2 +# 1045| r1045_5(glval) = VariableAddress[s] : +# 1045| r1045_6(String &) = Load : &:r1045_5, m1031_7 +# 1045| r1045_7(glval) = CopyValue : r1045_6 +# 1045| r1045_8(String &) = CopyValue : r1045_7 +# 1045| m1045_9(String &) = Store : &:r1045_4, r1045_8 +# 1045| m1045_10(decltype([...](...){...})) = Chi : total:m1045_3, partial:m1045_9 +# 1045| r1045_11(glval) = FieldAddress[x] : r1045_2 +# 1045| r1045_12(glval) = VariableAddress[x] : +# 1045| r1045_13(int) = Load : &:r1045_12, m1031_5 +# 1045| m1045_14(int) = Store : &:r1045_11, r1045_13 +# 1045| m1045_15(decltype([...](...){...})) = Chi : total:m1045_10, partial:m1045_14 +# 1045| r1045_16(glval) = FieldAddress[i] : r1045_2 +# 1045| r1045_17(glval) = VariableAddress[x] : +# 1045| r1045_18(int) = Load : &:r1045_17, m1031_5 +# 1045| r1045_19(int) = Constant[1] : +# 1045| r1045_20(int) = Add : r1045_18, r1045_19 +# 1045| m1045_21(int) = Store : &:r1045_16, r1045_20 +# 1045| m1045_22(decltype([...](...){...})) = Chi : total:m1045_15, partial:m1045_21 +# 1045| r1045_23(glval) = FieldAddress[j] : r1045_2 +# 1045| r1045_24(glval) = VariableAddress[r] : +# 1045| r1045_25(int &) = CopyValue : r1045_24 +# 1045| m1045_26(int &) = Store : &:r1045_23, r1045_25 +# 1045| m1045_27(decltype([...](...){...})) = Chi : total:m1045_22, partial:m1045_26 +# 1045| r1045_28(decltype([...](...){...})) = Load : &:r1045_2, ~m1045_27 +# 1045| m1045_29(decltype([...](...){...})) = Store : &:r1045_1, r1045_28 +# 1046| r1046_1(glval) = VariableAddress[lambda_inits] : +# 1046| r1046_2(glval) = Convert : r1046_1 +# 1046| r1046_3(glval) = FunctionAddress[operator()] : +# 1046| r1046_4(float) = Constant[6.0] : +# 1046| r1046_5(char) = Call : func:r1046_3, this:r1046_2, 0:r1046_4 +# 1046| m1046_6(unknown) = ^CallSideEffect : ~m1043_7 +# 1046| m1046_7(unknown) = Chi : total:m1043_7, partial:m1046_6 +# 1046| v1046_8(void) = ^BufferReadSideEffect[-1] : &:r1046_2, ~m1045_29 +# 1046| m1046_9(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1046_2 +# 1046| m1046_10(decltype([...](...){...})) = Chi : total:m1045_29, partial:m1046_9 +# 1047| v1047_1(void) = NoOp : +# 1031| v1031_11(void) = ReturnIndirection : &:r1031_8, ~m1046_7 +# 1031| v1031_12(void) = ReturnVoid : +# 1031| v1031_13(void) = UnmodeledUse : mu* +# 1031| v1031_14(void) = AliasedUse : ~m1046_7 +# 1031| v1031_15(void) = ExitFunction : + +# 1032| char (void Lambda(int, String const&))::(lambda [] type at line 1032, col. 23)::operator()(float) const +# 1032| Block 0 +# 1032| v1032_1(void) = EnterFunction : +# 1032| m1032_2(unknown) = AliasedDefinition : +# 1032| mu1032_3(unknown) = UnmodeledDefinition : +# 1032| r1032_4(glval) = InitializeThis : +# 1032| r1032_5(glval) = VariableAddress[f] : +# 1032| m1032_6(float) = InitializeParameter[f] : &:r1032_5 +# 1032| r1032_7(glval) = VariableAddress[#return] : +# 1032| r1032_8(char) = Constant[65] : +# 1032| m1032_9(char) = Store : &:r1032_7, r1032_8 +# 1032| r1032_10(glval) = VariableAddress[#return] : +# 1032| v1032_11(void) = ReturnValue : &:r1032_10, m1032_9 +# 1032| v1032_12(void) = UnmodeledUse : mu* +# 1032| v1032_13(void) = AliasedUse : ~m1032_2 +# 1032| v1032_14(void) = ExitFunction : + +# 1032| char(* (void Lambda(int, String const&))::(lambda [] type at line 1032, col. 23)::operator char (*)(float)() const)(float) +# 1032| Block 0 +# 1032| v1032_1(void) = EnterFunction : +# 1032| m1032_2(unknown) = AliasedDefinition : +# 1032| mu1032_3(unknown) = UnmodeledDefinition : +# 1032| r1032_4(glval) = InitializeThis : +# 1032| r1032_5(glval<..(*)(..)>) = VariableAddress[#return] : +# 1032| r1032_6(..(*)(..)) = FunctionAddress[_FUN] : +# 1032| m1032_7(..(*)(..)) = Store : &:r1032_5, r1032_6 +# 1032| r1032_8(glval<..(*)(..)>) = VariableAddress[#return] : +# 1032| v1032_9(void) = ReturnValue : &:r1032_8, m1032_7 +# 1032| v1032_10(void) = UnmodeledUse : mu* +# 1032| v1032_11(void) = AliasedUse : ~m1032_2 +# 1032| v1032_12(void) = ExitFunction : + +# 1034| char (void Lambda(int, String const&))::(lambda [] type at line 1034, col. 21)::operator()(float) const +# 1034| Block 0 +# 1034| v1034_1(void) = EnterFunction : +# 1034| m1034_2(unknown) = AliasedDefinition : +# 1034| mu1034_3(unknown) = UnmodeledDefinition : +# 1034| r1034_4(glval) = InitializeThis : +# 1034| r1034_5(glval) = VariableAddress[f] : +# 1034| m1034_6(float) = InitializeParameter[f] : &:r1034_5 +# 1034| r1034_7(glval) = VariableAddress[#return] : +#-----| r0_1(lambda [] type at line 1034, col. 21 *) = CopyValue : r1034_4 +#-----| r0_2(glval) = FieldAddress[s] : r0_1 +#-----| r0_3(String &) = Load : &:r0_2, ~m1034_2 +# 1034| r1034_8(glval) = CopyValue : r0_3 +# 1034| r1034_9(glval) = FunctionAddress[c_str] : +# 1034| r1034_10(char *) = Call : func:r1034_9, this:r1034_8 +# 1034| m1034_11(unknown) = ^CallSideEffect : ~m1034_2 +# 1034| m1034_12(unknown) = Chi : total:m1034_2, partial:m1034_11 +# 1034| v1034_13(void) = ^BufferReadSideEffect[-1] : &:r1034_8, ~m1034_12 +# 1034| m1034_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r1034_8 +# 1034| m1034_15(unknown) = Chi : total:m1034_12, partial:m1034_14 +#-----| r0_4(lambda [] type at line 1034, col. 21 *) = CopyValue : r1034_4 +#-----| r0_5(glval) = FieldAddress[x] : r0_4 +#-----| r0_6(int &) = Load : &:r0_5, ~m1034_15 +# 1034| r1034_16(int) = Load : &:r0_6, ~m1034_15 +# 1034| r1034_17(glval) = PointerAdd[1] : r1034_10, r1034_16 +# 1034| r1034_18(char) = Load : &:r1034_17, ~m1034_15 +# 1034| m1034_19(char) = Store : &:r1034_7, r1034_18 +# 1034| r1034_20(glval) = VariableAddress[#return] : +# 1034| v1034_21(void) = ReturnValue : &:r1034_20, m1034_19 +# 1034| v1034_22(void) = UnmodeledUse : mu* +# 1034| v1034_23(void) = AliasedUse : ~m1034_15 +# 1034| v1034_24(void) = ExitFunction : + +# 1036| void (void Lambda(int, String const&))::(lambda [] type at line 1036, col. 21)::~() +# 1036| Block 0 +# 1036| v1036_1(void) = EnterFunction : +# 1036| m1036_2(unknown) = AliasedDefinition : +# 1036| mu1036_3(unknown) = UnmodeledDefinition : +# 1036| r1036_4(glval) = InitializeThis : +#-----| v0_1(void) = NoOp : +# 1036| r1036_5(glval) = FieldAddress[s] : r1036_4 +# 1036| r1036_6(glval) = FunctionAddress[~String] : +# 1036| v1036_7(void) = Call : func:r1036_6, this:r1036_5 +# 1036| m1036_8(unknown) = ^CallSideEffect : ~m1036_2 +# 1036| m1036_9(unknown) = Chi : total:m1036_2, partial:m1036_8 +# 1036| v1036_10(void) = ReturnVoid : +# 1036| v1036_11(void) = UnmodeledUse : mu* +# 1036| v1036_12(void) = AliasedUse : ~m1036_9 +# 1036| v1036_13(void) = ExitFunction : + +# 1036| char (void Lambda(int, String const&))::(lambda [] type at line 1036, col. 21)::operator()(float) const +# 1036| Block 0 +# 1036| v1036_1(void) = EnterFunction : +# 1036| m1036_2(unknown) = AliasedDefinition : +# 1036| mu1036_3(unknown) = UnmodeledDefinition : +# 1036| r1036_4(glval) = InitializeThis : +# 1036| r1036_5(glval) = VariableAddress[f] : +# 1036| m1036_6(float) = InitializeParameter[f] : &:r1036_5 +# 1036| r1036_7(glval) = VariableAddress[#return] : +#-----| r0_1(lambda [] type at line 1036, col. 21 *) = CopyValue : r1036_4 +#-----| r0_2(glval) = FieldAddress[s] : r0_1 +# 1036| r1036_8(glval) = FunctionAddress[c_str] : +# 1036| r1036_9(char *) = Call : func:r1036_8, this:r0_2 +# 1036| m1036_10(unknown) = ^CallSideEffect : ~m1036_2 +# 1036| m1036_11(unknown) = Chi : total:m1036_2, partial:m1036_10 +#-----| v0_3(void) = ^BufferReadSideEffect[-1] : &:r0_2, ~m1036_11 +#-----| m0_4(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_2 +#-----| m0_5(unknown) = Chi : total:m1036_11, partial:m0_4 +#-----| r0_6(lambda [] type at line 1036, col. 21 *) = CopyValue : r1036_4 +#-----| r0_7(glval) = FieldAddress[x] : r0_6 +#-----| r0_8(int) = Load : &:r0_7, ~m0_5 +# 1036| r1036_12(glval) = PointerAdd[1] : r1036_9, r0_8 +# 1036| r1036_13(char) = Load : &:r1036_12, ~m0_5 +# 1036| m1036_14(char) = Store : &:r1036_7, r1036_13 +# 1036| r1036_15(glval) = VariableAddress[#return] : +# 1036| v1036_16(void) = ReturnValue : &:r1036_15, m1036_14 +# 1036| v1036_17(void) = UnmodeledUse : mu* +# 1036| v1036_18(void) = AliasedUse : ~m0_5 +# 1036| v1036_19(void) = ExitFunction : + +# 1038| char (void Lambda(int, String const&))::(lambda [] type at line 1038, col. 30)::operator()(float) const +# 1038| Block 0 +# 1038| v1038_1(void) = EnterFunction : +# 1038| m1038_2(unknown) = AliasedDefinition : +# 1038| mu1038_3(unknown) = UnmodeledDefinition : +# 1038| r1038_4(glval) = InitializeThis : +# 1038| r1038_5(glval) = VariableAddress[f] : +# 1038| m1038_6(float) = InitializeParameter[f] : &:r1038_5 +# 1038| r1038_7(glval) = VariableAddress[#return] : +#-----| r0_1(lambda [] type at line 1038, col. 30 *) = CopyValue : r1038_4 +#-----| r0_2(glval) = FieldAddress[s] : r0_1 +#-----| r0_3(String &) = Load : &:r0_2, ~m1038_2 +# 1038| r1038_8(glval) = CopyValue : r0_3 +# 1038| r1038_9(glval) = FunctionAddress[c_str] : +# 1038| r1038_10(char *) = Call : func:r1038_9, this:r1038_8 +# 1038| m1038_11(unknown) = ^CallSideEffect : ~m1038_2 +# 1038| m1038_12(unknown) = Chi : total:m1038_2, partial:m1038_11 +# 1038| v1038_13(void) = ^BufferReadSideEffect[-1] : &:r1038_8, ~m1038_12 +# 1038| m1038_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r1038_8 +# 1038| m1038_15(unknown) = Chi : total:m1038_12, partial:m1038_14 +# 1038| r1038_16(int) = Constant[0] : +# 1038| r1038_17(glval) = PointerAdd[1] : r1038_10, r1038_16 +# 1038| r1038_18(char) = Load : &:r1038_17, ~m1038_15 +# 1038| m1038_19(char) = Store : &:r1038_7, r1038_18 +# 1038| r1038_20(glval) = VariableAddress[#return] : +# 1038| v1038_21(void) = ReturnValue : &:r1038_20, m1038_19 +# 1038| v1038_22(void) = UnmodeledUse : mu* +# 1038| v1038_23(void) = AliasedUse : ~m1038_15 +# 1038| v1038_24(void) = ExitFunction : + +# 1040| void (void Lambda(int, String const&))::(lambda [] type at line 1040, col. 30)::~() +# 1040| Block 0 +# 1040| v1040_1(void) = EnterFunction : +# 1040| m1040_2(unknown) = AliasedDefinition : +# 1040| mu1040_3(unknown) = UnmodeledDefinition : +# 1040| r1040_4(glval) = InitializeThis : +#-----| v0_1(void) = NoOp : +# 1040| r1040_5(glval) = FieldAddress[s] : r1040_4 +# 1040| r1040_6(glval) = FunctionAddress[~String] : +# 1040| v1040_7(void) = Call : func:r1040_6, this:r1040_5 +# 1040| m1040_8(unknown) = ^CallSideEffect : ~m1040_2 +# 1040| m1040_9(unknown) = Chi : total:m1040_2, partial:m1040_8 +# 1040| v1040_10(void) = ReturnVoid : +# 1040| v1040_11(void) = UnmodeledUse : mu* +# 1040| v1040_12(void) = AliasedUse : ~m1040_9 +# 1040| v1040_13(void) = ExitFunction : + +# 1040| char (void Lambda(int, String const&))::(lambda [] type at line 1040, col. 30)::operator()(float) const +# 1040| Block 0 +# 1040| v1040_1(void) = EnterFunction : +# 1040| m1040_2(unknown) = AliasedDefinition : +# 1040| mu1040_3(unknown) = UnmodeledDefinition : +# 1040| r1040_4(glval) = InitializeThis : +# 1040| r1040_5(glval) = VariableAddress[f] : +# 1040| m1040_6(float) = InitializeParameter[f] : &:r1040_5 +# 1040| r1040_7(glval) = VariableAddress[#return] : +#-----| r0_1(lambda [] type at line 1040, col. 30 *) = CopyValue : r1040_4 +#-----| r0_2(glval) = FieldAddress[s] : r0_1 +# 1040| r1040_8(glval) = FunctionAddress[c_str] : +# 1040| r1040_9(char *) = Call : func:r1040_8, this:r0_2 +# 1040| m1040_10(unknown) = ^CallSideEffect : ~m1040_2 +# 1040| m1040_11(unknown) = Chi : total:m1040_2, partial:m1040_10 +#-----| v0_3(void) = ^BufferReadSideEffect[-1] : &:r0_2, ~m1040_11 +#-----| m0_4(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_2 +#-----| m0_5(unknown) = Chi : total:m1040_11, partial:m0_4 +# 1040| r1040_12(int) = Constant[0] : +# 1040| r1040_13(glval) = PointerAdd[1] : r1040_9, r1040_12 +# 1040| r1040_14(char) = Load : &:r1040_13, ~m0_5 +# 1040| m1040_15(char) = Store : &:r1040_7, r1040_14 +# 1040| r1040_16(glval) = VariableAddress[#return] : +# 1040| v1040_17(void) = ReturnValue : &:r1040_16, m1040_15 +# 1040| v1040_18(void) = UnmodeledUse : mu* +# 1040| v1040_19(void) = AliasedUse : ~m0_5 +# 1040| v1040_20(void) = ExitFunction : + +# 1042| char (void Lambda(int, String const&))::(lambda [] type at line 1042, col. 32)::operator()(float) const +# 1042| Block 0 +# 1042| v1042_1(void) = EnterFunction : +# 1042| m1042_2(unknown) = AliasedDefinition : +# 1042| mu1042_3(unknown) = UnmodeledDefinition : +# 1042| r1042_4(glval) = InitializeThis : +# 1042| r1042_5(glval) = VariableAddress[f] : +# 1042| m1042_6(float) = InitializeParameter[f] : &:r1042_5 +# 1042| r1042_7(glval) = VariableAddress[#return] : +#-----| r0_1(lambda [] type at line 1042, col. 32 *) = CopyValue : r1042_4 +#-----| r0_2(glval) = FieldAddress[s] : r0_1 +#-----| r0_3(String &) = Load : &:r0_2, ~m1042_2 +# 1042| r1042_8(glval) = CopyValue : r0_3 +# 1042| r1042_9(glval) = FunctionAddress[c_str] : +# 1042| r1042_10(char *) = Call : func:r1042_9, this:r1042_8 +# 1042| m1042_11(unknown) = ^CallSideEffect : ~m1042_2 +# 1042| m1042_12(unknown) = Chi : total:m1042_2, partial:m1042_11 +# 1042| v1042_13(void) = ^BufferReadSideEffect[-1] : &:r1042_8, ~m1042_12 +# 1042| m1042_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r1042_8 +# 1042| m1042_15(unknown) = Chi : total:m1042_12, partial:m1042_14 +#-----| r0_4(lambda [] type at line 1042, col. 32 *) = CopyValue : r1042_4 +#-----| r0_5(glval) = FieldAddress[x] : r0_4 +#-----| r0_6(int) = Load : &:r0_5, ~m1042_15 +# 1042| r1042_16(glval) = PointerAdd[1] : r1042_10, r0_6 +# 1042| r1042_17(char) = Load : &:r1042_16, ~m1042_15 +# 1042| m1042_18(char) = Store : &:r1042_7, r1042_17 +# 1042| r1042_19(glval) = VariableAddress[#return] : +# 1042| v1042_20(void) = ReturnValue : &:r1042_19, m1042_18 +# 1042| v1042_21(void) = UnmodeledUse : mu* +# 1042| v1042_22(void) = AliasedUse : ~m1042_15 +# 1042| v1042_23(void) = ExitFunction : + +# 1045| char (void Lambda(int, String const&))::(lambda [] type at line 1045, col. 23)::operator()(float) const +# 1045| Block 0 +# 1045| v1045_1(void) = EnterFunction : +# 1045| m1045_2(unknown) = AliasedDefinition : +# 1045| mu1045_3(unknown) = UnmodeledDefinition : +# 1045| r1045_4(glval) = InitializeThis : +# 1045| r1045_5(glval) = VariableAddress[f] : +# 1045| m1045_6(float) = InitializeParameter[f] : &:r1045_5 +# 1045| r1045_7(glval) = VariableAddress[#return] : +#-----| r0_1(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 +#-----| r0_2(glval) = FieldAddress[s] : r0_1 +#-----| r0_3(String &) = Load : &:r0_2, ~m1045_2 +# 1045| r1045_8(glval) = CopyValue : r0_3 +# 1045| r1045_9(glval) = FunctionAddress[c_str] : +# 1045| r1045_10(char *) = Call : func:r1045_9, this:r1045_8 +# 1045| m1045_11(unknown) = ^CallSideEffect : ~m1045_2 +# 1045| m1045_12(unknown) = Chi : total:m1045_2, partial:m1045_11 +# 1045| v1045_13(void) = ^BufferReadSideEffect[-1] : &:r1045_8, ~m1045_12 +# 1045| m1045_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r1045_8 +# 1045| m1045_15(unknown) = Chi : total:m1045_12, partial:m1045_14 +#-----| r0_4(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 +#-----| r0_5(glval) = FieldAddress[x] : r0_4 +#-----| r0_6(int) = Load : &:r0_5, ~m1045_15 +#-----| r0_7(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 +# 1045| r1045_16(glval) = FieldAddress[i] : r0_7 +# 1045| r1045_17(int) = Load : &:r1045_16, ~m1045_15 +# 1045| r1045_18(int) = Add : r0_6, r1045_17 +#-----| r0_8(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 +# 1045| r1045_19(glval) = FieldAddress[j] : r0_8 +# 1045| r1045_20(int &) = Load : &:r1045_19, ~m1045_15 +# 1045| r1045_21(int) = Load : &:r1045_20, ~m1045_15 +# 1045| r1045_22(int) = Sub : r1045_18, r1045_21 +# 1045| r1045_23(glval) = PointerAdd[1] : r1045_10, r1045_22 +# 1045| r1045_24(char) = Load : &:r1045_23, ~m1045_15 +# 1045| m1045_25(char) = Store : &:r1045_7, r1045_24 +# 1045| r1045_26(glval) = VariableAddress[#return] : +# 1045| v1045_27(void) = ReturnValue : &:r1045_26, m1045_25 +# 1045| v1045_28(void) = UnmodeledUse : mu* +# 1045| v1045_29(void) = AliasedUse : ~m1045_15 +# 1045| v1045_30(void) = ExitFunction : + +# 1068| void RangeBasedFor(vector const&) +# 1068| Block 0 +# 1068| v1068_1(void) = EnterFunction : +# 1068| m1068_2(unknown) = AliasedDefinition : +# 1068| mu1068_3(unknown) = UnmodeledDefinition : +# 1068| r1068_4(glval &>) = VariableAddress[v] : +# 1068| m1068_5(vector &) = InitializeParameter[v] : &:r1068_4 +# 1068| r1068_6(vector &) = Load : &:r1068_4, m1068_5 +# 1068| m1068_7(unknown) = InitializeIndirection[v] : &:r1068_6 +# 1068| m1068_8(unknown) = Chi : total:m1068_2, partial:m1068_7 +# 1069| r1069_1(glval &>) = VariableAddress[(__range)] : +# 1069| r1069_2(glval &>) = VariableAddress[v] : +# 1069| r1069_3(vector &) = Load : &:r1069_2, m1068_5 +# 1069| r1069_4(glval>) = CopyValue : r1069_3 +# 1069| r1069_5(vector &) = CopyValue : r1069_4 +# 1069| m1069_6(vector &) = Store : &:r1069_1, r1069_5 +# 1069| r1069_7(glval) = VariableAddress[(__begin)] : +#-----| r0_1(glval &>) = VariableAddress[(__range)] : +#-----| r0_2(vector &) = Load : &:r0_1, m1069_6 +#-----| r0_3(glval>) = CopyValue : r0_2 +# 1069| r1069_8(glval) = FunctionAddress[begin] : +# 1069| r1069_9(iterator) = Call : func:r1069_8, this:r0_3 +# 1069| m1069_10(unknown) = ^CallSideEffect : ~m1068_8 +# 1069| m1069_11(unknown) = Chi : total:m1068_8, partial:m1069_10 +#-----| v0_4(void) = ^BufferReadSideEffect[-1] : &:r0_3, ~m1069_11 +#-----| m0_5(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_3 +#-----| m0_6(unknown) = Chi : total:m1069_11, partial:m0_5 +# 1069| m1069_12(iterator) = Store : &:r1069_7, r1069_9 +# 1069| r1069_13(glval) = VariableAddress[(__end)] : +#-----| r0_7(glval &>) = VariableAddress[(__range)] : +#-----| r0_8(vector &) = Load : &:r0_7, m1069_6 +#-----| r0_9(glval>) = CopyValue : r0_8 +# 1069| r1069_14(glval) = FunctionAddress[end] : +# 1069| r1069_15(iterator) = Call : func:r1069_14, this:r0_9 +# 1069| m1069_16(unknown) = ^CallSideEffect : ~m0_6 +# 1069| m1069_17(unknown) = Chi : total:m0_6, partial:m1069_16 +#-----| v0_10(void) = ^BufferReadSideEffect[-1] : &:r0_9, ~m1069_17 +#-----| m0_11(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_9 +#-----| m0_12(unknown) = Chi : total:m1069_17, partial:m0_11 +# 1069| m1069_18(iterator) = Store : &:r1069_13, r1069_15 +#-----| Goto -> Block 6 + +#-----| Block 1 +#-----| m0_13(iterator) = Phi : from 2:m0_25, from 10:m1075_31 +#-----| m0_14(unknown) = Phi : from 2:~m1075_9, from 10:~m0_60 +#-----| r0_15(glval) = VariableAddress[(__begin)] : +#-----| r0_16(glval) = Convert : r0_15 +# 1075| r1075_1(glval) = FunctionAddress[operator!=] : +#-----| r0_17(glval) = VariableAddress[(__end)] : +#-----| r0_18(iterator) = Load : &:r0_17, m1075_37 +# 1075| r1075_2(bool) = Call : func:r1075_1, this:r0_16, 0:r0_18 +# 1075| m1075_3(unknown) = ^CallSideEffect : ~m0_14 +# 1075| m1075_4(unknown) = Chi : total:m0_14, partial:m1075_3 +#-----| v0_19(void) = ^BufferReadSideEffect[-1] : &:r0_16, ~m0_13 +#-----| m0_20(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_16 +#-----| m0_21(iterator) = Chi : total:m0_13, partial:m0_20 +# 1075| v1075_5(void) = ConditionalBranch : r1075_2 +#-----| False -> Block 5 +#-----| True -> Block 3 + +#-----| Block 2 +#-----| r0_22(glval) = VariableAddress[(__begin)] : +# 1075| r1075_6(glval) = FunctionAddress[operator++] : +# 1075| r1075_7(iterator &) = Call : func:r1075_6, this:r0_22 +# 1075| m1075_8(unknown) = ^CallSideEffect : ~m1075_15 +# 1075| m1075_9(unknown) = Chi : total:m1075_15, partial:m1075_8 +#-----| v0_23(void) = ^BufferReadSideEffect[-1] : &:r0_22, ~m0_30 +#-----| m0_24(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_22 +#-----| m0_25(iterator) = Chi : total:m0_30, partial:m0_24 +# 1075| r1075_10(glval) = CopyValue : r1075_7 +#-----| Goto (back edge) -> Block 1 + +# 1075| Block 3 +# 1075| r1075_11(glval) = VariableAddress[e] : +#-----| r0_26(glval) = VariableAddress[(__begin)] : +#-----| r0_27(glval) = Convert : r0_26 +# 1075| r1075_12(glval) = FunctionAddress[operator*] : +# 1075| r1075_13(int &) = Call : func:r1075_12, this:r0_27 +# 1075| m1075_14(unknown) = ^CallSideEffect : ~m1075_4 +# 1075| m1075_15(unknown) = Chi : total:m1075_4, partial:m1075_14 +#-----| v0_28(void) = ^BufferReadSideEffect[-1] : &:r0_27, ~m0_21 +#-----| m0_29(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_27 +#-----| m0_30(iterator) = Chi : total:m0_21, partial:m0_29 +# 1075| r1075_16(glval) = CopyValue : r1075_13 +# 1075| r1075_17(glval) = Convert : r1075_16 +# 1075| r1075_18(int &) = CopyValue : r1075_17 +# 1075| m1075_19(int &) = Store : &:r1075_11, r1075_18 +# 1076| r1076_1(glval) = VariableAddress[e] : +# 1076| r1076_2(int &) = Load : &:r1076_1, m1075_19 +# 1076| r1076_3(int) = Load : &:r1076_2, ~m1075_15 +# 1076| r1076_4(int) = Constant[5] : +# 1076| r1076_5(bool) = CompareLT : r1076_3, r1076_4 +# 1076| v1076_6(void) = ConditionalBranch : r1076_5 +#-----| False -> Block 2 +#-----| True -> Block 4 + +# 1077| Block 4 +# 1077| v1077_1(void) = NoOp : +#-----| Goto -> Block 5 + +# 1079| Block 5 +# 1079| m1079_1(unknown) = Phi : from 1:~m1075_4, from 4:~m1075_15 +# 1079| v1079_2(void) = NoOp : +# 1080| v1080_1(void) = NoOp : +# 1068| v1068_9(void) = ReturnIndirection : &:r1068_6, ~m1079_1 +# 1068| v1068_10(void) = ReturnVoid : +# 1068| v1068_11(void) = UnmodeledUse : mu* +# 1068| v1068_12(void) = AliasedUse : ~m1079_1 +# 1068| v1068_13(void) = ExitFunction : + +#-----| Block 6 +#-----| m0_31(iterator) = Phi : from 0:m1069_12, from 9:m0_48 +#-----| m0_32(unknown) = Phi : from 0:~m0_12, from 9:~m1069_35 +#-----| r0_33(glval) = VariableAddress[(__begin)] : +#-----| r0_34(glval) = Convert : r0_33 +# 1069| r1069_19(glval) = FunctionAddress[operator!=] : +#-----| r0_35(glval) = VariableAddress[(__end)] : +#-----| r0_36(iterator) = Load : &:r0_35, m1069_18 +# 1069| r1069_20(bool) = Call : func:r1069_19, this:r0_34, 0:r0_36 +# 1069| m1069_21(unknown) = ^CallSideEffect : ~m0_32 +# 1069| m1069_22(unknown) = Chi : total:m0_32, partial:m1069_21 +#-----| v0_37(void) = ^BufferReadSideEffect[-1] : &:r0_34, ~m0_31 +#-----| m0_38(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_34 +#-----| m0_39(iterator) = Chi : total:m0_31, partial:m0_38 +# 1069| v1069_23(void) = ConditionalBranch : r1069_20 +#-----| False -> Block 10 +#-----| True -> Block 7 + +# 1069| Block 7 +# 1069| r1069_24(glval) = VariableAddress[e] : +#-----| r0_40(glval) = VariableAddress[(__begin)] : +#-----| r0_41(glval) = Convert : r0_40 +# 1069| r1069_25(glval) = FunctionAddress[operator*] : +# 1069| r1069_26(int &) = Call : func:r1069_25, this:r0_41 +# 1069| m1069_27(unknown) = ^CallSideEffect : ~m1069_22 +# 1069| m1069_28(unknown) = Chi : total:m1069_22, partial:m1069_27 +#-----| v0_42(void) = ^BufferReadSideEffect[-1] : &:r0_41, ~m0_39 +#-----| m0_43(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_41 +#-----| m0_44(iterator) = Chi : total:m0_39, partial:m0_43 +# 1069| r1069_29(int) = Load : &:r1069_26, ~m1069_28 +# 1069| m1069_30(int) = Store : &:r1069_24, r1069_29 +# 1070| r1070_1(glval) = VariableAddress[e] : +# 1070| r1070_2(int) = Load : &:r1070_1, m1069_30 +# 1070| r1070_3(int) = Constant[0] : +# 1070| r1070_4(bool) = CompareGT : r1070_2, r1070_3 +# 1070| v1070_5(void) = ConditionalBranch : r1070_4 +#-----| False -> Block 9 +#-----| True -> Block 8 + +# 1071| Block 8 +# 1071| v1071_1(void) = NoOp : +#-----| Goto -> Block 9 + +# 1069| Block 9 +# 1069| v1069_31(void) = NoOp : +#-----| r0_45(glval) = VariableAddress[(__begin)] : +# 1069| r1069_32(glval) = FunctionAddress[operator++] : +# 1069| r1069_33(iterator &) = Call : func:r1069_32, this:r0_45 +# 1069| m1069_34(unknown) = ^CallSideEffect : ~m1069_28 +# 1069| m1069_35(unknown) = Chi : total:m1069_28, partial:m1069_34 +#-----| v0_46(void) = ^BufferReadSideEffect[-1] : &:r0_45, ~m0_44 +#-----| m0_47(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_45 +#-----| m0_48(iterator) = Chi : total:m0_44, partial:m0_47 +# 1069| r1069_36(glval) = CopyValue : r1069_33 +#-----| Goto (back edge) -> Block 6 + +# 1075| Block 10 +# 1075| r1075_20(glval &>) = VariableAddress[(__range)] : +# 1075| r1075_21(glval &>) = VariableAddress[v] : +# 1075| r1075_22(vector &) = Load : &:r1075_21, m1068_5 +# 1075| r1075_23(glval>) = CopyValue : r1075_22 +# 1075| r1075_24(vector &) = CopyValue : r1075_23 +# 1075| m1075_25(vector &) = Store : &:r1075_20, r1075_24 +# 1075| r1075_26(glval) = VariableAddress[(__begin)] : +#-----| r0_49(glval &>) = VariableAddress[(__range)] : +#-----| r0_50(vector &) = Load : &:r0_49, m1075_25 +#-----| r0_51(glval>) = CopyValue : r0_50 +# 1075| r1075_27(glval) = FunctionAddress[begin] : +# 1075| r1075_28(iterator) = Call : func:r1075_27, this:r0_51 +# 1075| m1075_29(unknown) = ^CallSideEffect : ~m1069_22 +# 1075| m1075_30(unknown) = Chi : total:m1069_22, partial:m1075_29 +#-----| v0_52(void) = ^BufferReadSideEffect[-1] : &:r0_51, ~m1075_30 +#-----| m0_53(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_51 +#-----| m0_54(unknown) = Chi : total:m1075_30, partial:m0_53 +# 1075| m1075_31(iterator) = Store : &:r1075_26, r1075_28 +# 1075| r1075_32(glval) = VariableAddress[(__end)] : +#-----| r0_55(glval &>) = VariableAddress[(__range)] : +#-----| r0_56(vector &) = Load : &:r0_55, m1075_25 +#-----| r0_57(glval>) = CopyValue : r0_56 +# 1075| r1075_33(glval) = FunctionAddress[end] : +# 1075| r1075_34(iterator) = Call : func:r1075_33, this:r0_57 +# 1075| m1075_35(unknown) = ^CallSideEffect : ~m0_54 +# 1075| m1075_36(unknown) = Chi : total:m0_54, partial:m1075_35 +#-----| v0_58(void) = ^BufferReadSideEffect[-1] : &:r0_57, ~m1075_36 +#-----| m0_59(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_57 +#-----| m0_60(unknown) = Chi : total:m1075_36, partial:m0_59 +# 1075| m1075_37(iterator) = Store : &:r1075_32, r1075_34 +#-----| Goto -> Block 1 + +# 1099| int AsmStmt(int) +# 1099| Block 0 +# 1099| v1099_1(void) = EnterFunction : +# 1099| m1099_2(unknown) = AliasedDefinition : +# 1099| mu1099_3(unknown) = UnmodeledDefinition : +# 1099| r1099_4(glval) = VariableAddress[x] : +# 1099| m1099_5(int) = InitializeParameter[x] : &:r1099_4 +# 1100| m1100_1(unknown) = InlineAsm : ~m1099_2 +# 1100| m1100_2(unknown) = Chi : total:m1099_2, partial:m1100_1 +# 1101| r1101_1(glval) = VariableAddress[#return] : +# 1101| r1101_2(glval) = VariableAddress[x] : +# 1101| r1101_3(int) = Load : &:r1101_2, m1099_5 +# 1101| m1101_4(int) = Store : &:r1101_1, r1101_3 +# 1099| r1099_6(glval) = VariableAddress[#return] : +# 1099| v1099_7(void) = ReturnValue : &:r1099_6, m1101_4 +# 1099| v1099_8(void) = UnmodeledUse : mu* +# 1099| v1099_9(void) = AliasedUse : ~m1100_2 +# 1099| v1099_10(void) = ExitFunction : + +# 1104| void AsmStmtWithOutputs(unsigned int&, unsigned int, unsigned int&, unsigned int) +# 1104| Block 0 +# 1104| v1104_1(void) = EnterFunction : +# 1104| m1104_2(unknown) = AliasedDefinition : +# 1104| mu1104_3(unknown) = UnmodeledDefinition : +# 1104| r1104_4(glval) = VariableAddress[a] : +# 1104| m1104_5(unsigned int &) = InitializeParameter[a] : &:r1104_4 +# 1104| r1104_6(unsigned int &) = Load : &:r1104_4, m1104_5 +# 1104| m1104_7(unknown) = InitializeIndirection[a] : &:r1104_6 +# 1104| m1104_8(unknown) = Chi : total:m1104_2, partial:m1104_7 +# 1104| r1104_9(glval) = VariableAddress[b] : +# 1104| m1104_10(unsigned int) = InitializeParameter[b] : &:r1104_9 +# 1104| r1104_11(glval) = VariableAddress[c] : +# 1104| m1104_12(unsigned int &) = InitializeParameter[c] : &:r1104_11 +# 1104| r1104_13(unsigned int &) = Load : &:r1104_11, m1104_12 +# 1104| m1104_14(unknown) = InitializeIndirection[c] : &:r1104_13 +# 1104| m1104_15(unknown) = Chi : total:m1104_8, partial:m1104_14 +# 1104| r1104_16(glval) = VariableAddress[d] : +# 1104| m1104_17(unsigned int) = InitializeParameter[d] : &:r1104_16 +# 1109| r1109_1(glval) = VariableAddress[a] : +# 1109| r1109_2(unsigned int &) = Load : &:r1109_1, m1104_5 +# 1109| r1109_3(glval) = CopyValue : r1109_2 +# 1109| r1109_4(glval) = VariableAddress[b] : +# 1109| r1109_5(glval) = VariableAddress[c] : +# 1109| r1109_6(unsigned int &) = Load : &:r1109_5, m1104_12 +# 1109| r1109_7(unsigned int) = Load : &:r1109_6, ~m1104_15 +# 1109| r1109_8(glval) = VariableAddress[d] : +# 1109| r1109_9(unsigned int) = Load : &:r1109_8, m1104_17 +# 1106| m1106_1(unknown) = InlineAsm : ~m1104_15, 0:r1109_3, 1:r1109_4, 2:r1109_7, 3:r1109_9 +# 1106| m1106_2(unknown) = Chi : total:m1104_15, partial:m1106_1 +# 1111| v1111_1(void) = NoOp : +# 1104| v1104_18(void) = ReturnIndirection : &:r1104_6, ~m1106_2 +# 1104| v1104_19(void) = ReturnIndirection : &:r1104_13, ~m1106_2 +# 1104| v1104_20(void) = ReturnVoid : +# 1104| v1104_21(void) = UnmodeledUse : mu* +# 1104| v1104_22(void) = AliasedUse : ~m1106_2 +# 1104| v1104_23(void) = ExitFunction : + +# 1113| void ExternDeclarations() +# 1113| Block 0 +# 1113| v1113_1(void) = EnterFunction : +# 1113| m1113_2(unknown) = AliasedDefinition : +# 1113| mu1113_3(unknown) = UnmodeledDefinition : +# 1116| r1116_1(glval) = VariableAddress[x] : +# 1116| m1116_2(int) = Uninitialized[x] : &:r1116_1 +# 1117| r1117_1(glval) = VariableAddress[y] : +# 1117| m1117_2(int) = Uninitialized[y] : &:r1117_1 +# 1118| r1118_1(glval) = VariableAddress[h] : +# 1118| m1118_2(int) = Uninitialized[h] : &:r1118_1 +# 1120| v1120_1(void) = NoOp : +# 1113| v1113_4(void) = ReturnVoid : +# 1113| v1113_5(void) = UnmodeledUse : mu* +# 1113| v1113_6(void) = AliasedUse : ~m1113_2 +# 1113| v1113_7(void) = ExitFunction : + +# 1128| void ExternDeclarationsInMacro() +# 1128| Block 0 +# 1128| v1128_1(void) = EnterFunction : +# 1128| m1128_2(unknown) = AliasedDefinition : +# 1128| mu1128_3(unknown) = UnmodeledDefinition : +# 1130| r1130_1(glval) = VariableAddress[i] : +# 1130| r1130_2(int) = Constant[0] : +# 1130| m1130_3(int) = Store : &:r1130_1, r1130_2 +#-----| Goto -> Block 1 + +# 1130| Block 1 +# 1130| m1130_4(int) = Phi : from 0:m1130_3, from 2:m1130_14 +# 1130| r1130_5(glval) = VariableAddress[i] : +# 1130| r1130_6(int) = Load : &:r1130_5, m1130_4 +# 1130| r1130_7(int) = Constant[10] : +# 1130| r1130_8(bool) = CompareLT : r1130_6, r1130_7 +# 1130| v1130_9(void) = ConditionalBranch : r1130_8 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 1130| Block 2 +# 1130| r1130_10(glval) = VariableAddress[i] : +# 1130| r1130_11(int) = Load : &:r1130_10, m1130_4 +# 1130| r1130_12(int) = Constant[1] : +# 1130| r1130_13(int) = Add : r1130_11, r1130_12 +# 1130| m1130_14(int) = Store : &:r1130_10, r1130_13 +#-----| Goto (back edge) -> Block 1 + +# 1130| Block 3 +# 1130| v1130_15(void) = NoOp : +# 1131| v1131_1(void) = NoOp : +# 1128| v1128_4(void) = ReturnVoid : +# 1128| v1128_5(void) = UnmodeledUse : mu* +# 1128| v1128_6(void) = AliasedUse : ~m1128_2 +# 1128| v1128_7(void) = ExitFunction : + +# 1133| void TryCatchNoCatchAny(bool) +# 1133| Block 0 +# 1133| v1133_1(void) = EnterFunction : +# 1133| m1133_2(unknown) = AliasedDefinition : +# 1133| mu1133_3(unknown) = UnmodeledDefinition : +# 1133| r1133_4(glval) = VariableAddress[b] : +# 1133| m1133_5(bool) = InitializeParameter[b] : &:r1133_4 +# 1135| r1135_1(glval) = VariableAddress[x] : +# 1135| r1135_2(int) = Constant[5] : +# 1135| m1135_3(int) = Store : &:r1135_1, r1135_2 +# 1136| r1136_1(glval) = VariableAddress[b] : +# 1136| r1136_2(bool) = Load : &:r1136_1, m1133_5 +# 1136| v1136_3(void) = ConditionalBranch : r1136_2 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 1133| Block 1 +# 1133| m1133_6(unknown) = Phi : from 2:~m1133_10, from 10:~m1149_1 +# 1133| v1133_7(void) = UnmodeledUse : mu* +# 1133| v1133_8(void) = AliasedUse : ~m1133_6 +# 1133| v1133_9(void) = ExitFunction : + +# 1133| Block 2 +# 1133| m1133_10(unknown) = Phi : from 7:~m1145_13, from 8:~m1133_2 +# 1133| v1133_11(void) = Unwind : +#-----| Goto -> Block 1 + +# 1137| Block 3 +# 1137| r1137_1(glval) = VariableAddress[#throw1137:7] : +# 1137| r1137_2(glval) = StringConstant["string literal"] : +# 1137| r1137_3(char *) = Convert : r1137_2 +# 1137| m1137_4(char *) = Store : &:r1137_1, r1137_3 +# 1137| v1137_5(void) = ThrowValue : &:r1137_1, m1137_4 +#-----| Exception -> Block 6 + +# 1139| Block 4 +# 1139| r1139_1(glval) = VariableAddress[x] : +# 1139| r1139_2(int) = Load : &:r1139_1, m1135_3 +# 1139| r1139_3(int) = Constant[2] : +# 1139| r1139_4(bool) = CompareLT : r1139_2, r1139_3 +# 1139| v1139_5(void) = ConditionalBranch : r1139_4 +#-----| False -> Block 5 +#-----| True -> Block 11 + +# 1142| Block 5 +# 1142| r1142_1(int) = Constant[7] : +# 1142| r1142_2(glval) = VariableAddress[x] : +# 1142| m1142_3(int) = Store : &:r1142_2, r1142_1 +#-----| Goto -> Block 10 + +# 1144| Block 6 +# 1144| v1144_1(void) = CatchByType[const char *] : +#-----| Exception -> Block 8 +#-----| Goto -> Block 7 + +# 1144| Block 7 +# 1144| r1144_2(glval) = VariableAddress[s] : +# 1144| m1144_3(char *) = InitializeParameter[s] : &:r1144_2 +# 1144| r1144_4(char *) = Load : &:r1144_2, m1144_3 +# 1144| m1144_5(unknown) = InitializeIndirection[s] : &:r1144_4 +# 1144| m1144_6(unknown) = Chi : total:m1133_2, partial:m1144_5 +# 1145| r1145_1(glval) = VariableAddress[#throw1145:5] : +# 1145| m1145_2(String) = Uninitialized[#throw1145:5] : &:r1145_1 +# 1145| r1145_3(glval) = FunctionAddress[String] : +# 1145| r1145_4(glval) = VariableAddress[s] : +# 1145| r1145_5(char *) = Load : &:r1145_4, m1144_3 +# 1145| v1145_6(void) = Call : func:r1145_3, this:r1145_1, 0:r1145_5 +# 1145| m1145_7(unknown) = ^CallSideEffect : ~m1144_6 +# 1145| m1145_8(unknown) = Chi : total:m1144_6, partial:m1145_7 +# 1145| m1145_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r1145_1 +# 1145| m1145_10(String) = Chi : total:m1145_2, partial:m1145_9 +# 1145| v1145_11(void) = ^BufferReadSideEffect[0] : &:r1145_5, ~m1145_8 +# 1145| m1145_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r1145_5 +# 1145| m1145_13(unknown) = Chi : total:m1145_8, partial:m1145_12 +# 1145| v1145_14(void) = ThrowValue : &:r1145_1, ~m1145_10 +#-----| Exception -> Block 2 + +# 1147| Block 8 +# 1147| v1147_1(void) = CatchByType[const String &] : +#-----| Exception -> Block 2 +#-----| Goto -> Block 9 + +# 1147| Block 9 +# 1147| r1147_2(glval) = VariableAddress[e] : +# 1147| m1147_3(String &) = InitializeParameter[e] : &:r1147_2 +# 1147| r1147_4(String &) = Load : &:r1147_2, m1147_3 +# 1147| m1147_5(unknown) = InitializeIndirection[e] : &:r1147_4 +# 1147| m1147_6(unknown) = Chi : total:m1133_2, partial:m1147_5 +# 1147| v1147_7(void) = NoOp : +#-----| Goto -> Block 10 + +# 1149| Block 10 +# 1149| m1149_1(unknown) = Phi : from 5:~m1133_2, from 9:~m1147_6 +# 1149| v1149_2(void) = NoOp : +# 1133| v1133_12(void) = ReturnVoid : +#-----| Goto -> Block 1 + +# 1133| Block 11 +# 1133| v1133_13(void) = Unreached : + +# 1153| void VectorTypes(int) +# 1153| Block 0 +# 1153| v1153_1(void) = EnterFunction : +# 1153| m1153_2(unknown) = AliasedDefinition : +# 1153| mu1153_3(unknown) = UnmodeledDefinition : +# 1153| r1153_4(glval) = VariableAddress[i] : +# 1153| m1153_5(int) = InitializeParameter[i] : &:r1153_4 +# 1154| r1154_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1154| m1154_2(__attribute((vector_size(16UL))) int) = Uninitialized[vi4] : &:r1154_1 +# 1154| r1154_3(int) = Constant[0] : +# 1154| r1154_4(glval) = PointerAdd[4] : r1154_1, r1154_3 +# 1154| r1154_5(int) = Constant[0] : +# 1154| m1154_6(int) = Store : &:r1154_4, r1154_5 +# 1154| m1154_7(__attribute((vector_size(16UL))) int) = Chi : total:m1154_2, partial:m1154_6 +# 1154| r1154_8(int) = Constant[1] : +# 1154| r1154_9(glval) = PointerAdd[4] : r1154_1, r1154_8 +# 1154| r1154_10(int) = Constant[1] : +# 1154| m1154_11(int) = Store : &:r1154_9, r1154_10 +# 1154| m1154_12(__attribute((vector_size(16UL))) int) = Chi : total:m1154_7, partial:m1154_11 +# 1154| r1154_13(int) = Constant[2] : +# 1154| r1154_14(glval) = PointerAdd[4] : r1154_1, r1154_13 +# 1154| r1154_15(int) = Constant[2] : +# 1154| m1154_16(int) = Store : &:r1154_14, r1154_15 +# 1154| m1154_17(__attribute((vector_size(16UL))) int) = Chi : total:m1154_12, partial:m1154_16 +# 1154| r1154_18(int) = Constant[3] : +# 1154| r1154_19(glval) = PointerAdd[4] : r1154_1, r1154_18 +# 1154| r1154_20(int) = Constant[3] : +# 1154| m1154_21(int) = Store : &:r1154_19, r1154_20 +# 1154| m1154_22(__attribute((vector_size(16UL))) int) = Chi : total:m1154_17, partial:m1154_21 +# 1155| r1155_1(glval) = VariableAddress[x] : +# 1155| r1155_2(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1155| r1155_3(glval) = VariableAddress[i] : +# 1155| r1155_4(int) = Load : &:r1155_3, m1153_5 +# 1155| r1155_5(glval) = PointerAdd[4] : r1155_2, r1155_4 +# 1155| r1155_6(int) = Load : &:r1155_5, ~m1154_22 +# 1155| m1155_7(int) = Store : &:r1155_1, r1155_6 +# 1156| r1156_1(glval) = VariableAddress[x] : +# 1156| r1156_2(int) = Load : &:r1156_1, m1155_7 +# 1156| r1156_3(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1156| r1156_4(glval) = VariableAddress[i] : +# 1156| r1156_5(int) = Load : &:r1156_4, m1153_5 +# 1156| r1156_6(glval) = PointerAdd[4] : r1156_3, r1156_5 +# 1156| m1156_7(int) = Store : &:r1156_6, r1156_2 +# 1156| m1156_8(__attribute((vector_size(16UL))) int) = Chi : total:m1154_22, partial:m1156_7 +# 1157| r1157_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4_shuffle] : +# 1157| r1157_2(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1157| r1157_3(__attribute((vector_size(16UL))) int) = Load : &:r1157_2, ~m1156_8 +# 1157| r1157_4(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1157| r1157_5(__attribute((vector_size(16UL))) int) = Load : &:r1157_4, ~m1156_8 +#-----| r0_1(int) = Constant[3] : +# 1157| r1157_6(int) = Constant[2] : +# 1157| r1157_7(int) = Constant[1] : +# 1157| r1157_8(int) = Constant[0] : +# 1157| r1157_9(__attribute((vector_size(16))) int) = BuiltIn[__builtin_shufflevector] : 0:r1157_3, 1:r1157_5, 2:r0_1, 3:r1157_6, 4:r1157_7, 5:r1157_8 +# 1157| m1157_10(__attribute((vector_size(16UL))) int) = Store : &:r1157_1, r1157_9 +# 1158| r1158_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1158| r1158_2(__attribute((vector_size(16UL))) int) = Load : &:r1158_1, ~m1156_8 +# 1158| r1158_3(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4_shuffle] : +# 1158| r1158_4(__attribute((vector_size(16UL))) int) = Load : &:r1158_3, m1157_10 +# 1158| r1158_5(__attribute((vector_size(16UL))) int) = Add : r1158_2, r1158_4 +# 1158| r1158_6(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1158| m1158_7(__attribute((vector_size(16UL))) int) = Store : &:r1158_6, r1158_5 +# 1159| v1159_1(void) = NoOp : +# 1153| v1153_6(void) = ReturnVoid : +# 1153| v1153_7(void) = UnmodeledUse : mu* +# 1153| v1153_8(void) = AliasedUse : ~m1153_2 +# 1153| v1153_9(void) = ExitFunction : + +# 1163| int ModeledCallTarget(int) +# 1163| Block 0 +# 1163| v1163_1(void) = EnterFunction : +# 1163| m1163_2(unknown) = AliasedDefinition : +# 1163| mu1163_3(unknown) = UnmodeledDefinition : +# 1163| r1163_4(glval) = VariableAddress[x] : +# 1163| m1163_5(int) = InitializeParameter[x] : &:r1163_4 +# 1164| r1164_1(glval) = VariableAddress[y] : +# 1164| m1164_2(int) = Uninitialized[y] : &:r1164_1 +# 1165| r1165_1(glval) = FunctionAddress[memcpy] : +# 1165| r1165_2(glval) = VariableAddress[y] : +# 1165| r1165_3(int *) = CopyValue : r1165_2 +# 1165| r1165_4(void *) = Convert : r1165_3 +# 1165| r1165_5(glval) = VariableAddress[x] : +# 1165| r1165_6(int *) = CopyValue : r1165_5 +# 1165| r1165_7(void *) = Convert : r1165_6 +# 1165| r1165_8(int) = Constant[4] : +# 1165| r1165_9(void *) = Call : func:r1165_1, 0:r1165_4, 1:r1165_7, 2:r1165_8 +# 1165| v1165_10(void) = ^SizedBufferReadSideEffect[1] : &:r1165_7, r1165_8, ~m1163_5 +# 1165| m1165_11(unknown) = ^SizedBufferMustWriteSideEffect[0] : &:r1165_4, r1165_8 +# 1165| m1165_12(int) = Chi : total:m1164_2, partial:m1165_11 +# 1166| r1166_1(glval) = VariableAddress[#return] : +# 1166| r1166_2(glval) = VariableAddress[y] : +# 1166| r1166_3(int) = Load : &:r1166_2, ~m1165_12 +# 1166| m1166_4(int) = Store : &:r1166_1, r1166_3 +# 1163| r1163_6(glval) = VariableAddress[#return] : +# 1163| v1163_7(void) = ReturnValue : &:r1163_6, m1166_4 +# 1163| v1163_8(void) = UnmodeledUse : mu* +# 1163| v1163_9(void) = AliasedUse : ~m1163_2 +# 1163| v1163_10(void) = ExitFunction : + +# 1169| String ReturnObjectImpl() +# 1169| Block 0 +# 1169| v1169_1(void) = EnterFunction : +# 1169| m1169_2(unknown) = AliasedDefinition : +# 1169| mu1169_3(unknown) = UnmodeledDefinition : +# 1170| r1170_1(glval) = VariableAddress[#return] : +# 1170| m1170_2(String) = Uninitialized[#return] : &:r1170_1 +# 1170| r1170_3(glval) = FunctionAddress[String] : +# 1170| r1170_4(glval) = StringConstant["foo"] : +# 1170| r1170_5(char *) = Convert : r1170_4 +# 1170| r1170_6(String) = Call : func:r1170_3, this:r1170_1, 0:r1170_5 +# 1170| m1170_7(unknown) = ^CallSideEffect : ~m1169_2 +# 1170| m1170_8(unknown) = Chi : total:m1169_2, partial:m1170_7 +# 1170| m1170_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r1170_1 +# 1170| m1170_10(String) = Chi : total:m1170_2, partial:m1170_9 +# 1170| v1170_11(void) = ^BufferReadSideEffect[0] : &:r1170_5, ~m1169_2 +# 1170| m1170_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r1170_5 +# 1170| m1170_13(unknown) = Chi : total:m1170_8, partial:m1170_12 +# 1169| r1169_4(glval) = VariableAddress[#return] : +# 1169| v1169_5(void) = ReturnValue : &:r1169_4, ~m1170_10 +# 1169| v1169_6(void) = UnmodeledUse : mu* +# 1169| v1169_7(void) = AliasedUse : ~m1170_13 +# 1169| v1169_8(void) = ExitFunction : + +perf-regression.cpp: +# 6| void Big::Big() +# 6| Block 0 +# 6| v6_1(void) = EnterFunction : +# 6| m6_2(unknown) = AliasedDefinition : +# 6| mu6_3(unknown) = UnmodeledDefinition : +# 6| r6_4(glval) = InitializeThis : +# 6| r6_5(glval) = FieldAddress[buffer] : r6_4 +# 6| r6_6(int) = Constant[0] : +# 6| r6_7(glval) = PointerAdd[1] : r6_5, r6_6 +# 6| r6_8(unknown[1073741824]) = Constant[0] : +# 6| m6_9(unknown[1073741824]) = Store : &:r6_7, r6_8 +# 6| m6_10(unknown) = Chi : total:m6_2, partial:m6_9 +# 6| v6_11(void) = NoOp : +# 6| v6_12(void) = ReturnVoid : +# 6| v6_13(void) = UnmodeledUse : mu* +# 6| v6_14(void) = AliasedUse : ~m6_10 +# 6| v6_15(void) = ExitFunction : + +# 9| int main() +# 9| Block 0 +# 9| v9_1(void) = EnterFunction : +# 9| m9_2(unknown) = AliasedDefinition : +# 9| mu9_3(unknown) = UnmodeledDefinition : +# 10| r10_1(glval) = VariableAddress[big] : +# 10| r10_2(glval) = FunctionAddress[operator new] : +# 10| r10_3(unsigned long) = Constant[1073741824] : +# 10| r10_4(void *) = Call : func:r10_2, 0:r10_3 +# 10| m10_5(unknown) = ^CallSideEffect : ~m9_2 +# 10| m10_6(unknown) = Chi : total:m9_2, partial:m10_5 +# 10| r10_7(Big *) = Convert : r10_4 +# 10| r10_8(glval) = FunctionAddress[Big] : +# 10| v10_9(void) = Call : func:r10_8, this:r10_7 +# 10| m10_10(unknown) = ^CallSideEffect : ~m10_6 +# 10| m10_11(unknown) = Chi : total:m10_6, partial:m10_10 +# 10| m10_12(Big) = ^IndirectMayWriteSideEffect[-1] : &:r10_7 +# 10| m10_13(unknown) = Chi : total:m10_11, partial:m10_12 +# 10| m10_14(Big *) = Store : &:r10_1, r10_7 +# 12| r12_1(glval) = VariableAddress[#return] : +# 12| r12_2(int) = Constant[0] : +# 12| m12_3(int) = Store : &:r12_1, r12_2 +# 9| r9_4(glval) = VariableAddress[#return] : +# 9| v9_5(void) = ReturnValue : &:r9_4, m12_3 +# 9| v9_6(void) = UnmodeledUse : mu* +# 9| v9_7(void) = AliasedUse : ~m10_13 +# 9| v9_8(void) = ExitFunction : diff --git a/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.qlref b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.qlref new file mode 100644 index 00000000000..b9f65b3881d --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.qlref @@ -0,0 +1 @@ +semmle/code/cpp/ir/implementation/aliased_ssa/PrintIR.ql \ No newline at end of file diff --git a/cpp/ql/test/library-tests/ir/ir/aliased_ssa_sanity.ql b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_sanity.ql new file mode 100644 index 00000000000..74fa11944a6 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_sanity.ql @@ -0,0 +1,2 @@ +import semmle.code.cpp.ir.implementation.aliased_ssa.IRSanity +import semmle.code.cpp.ir.implementation.UseSoundEscapeAnalysis diff --git a/cpp/ql/test/library-tests/ir/ir/aliased_ssa_sanity_unsound.expected b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_sanity_unsound.expected new file mode 100644 index 00000000000..e5e666c020b --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_sanity_unsound.expected @@ -0,0 +1,26 @@ +missingOperand +| ir.cpp:809:7:809:13 | IndirectMayWriteSideEffect: call to Base | Instruction 'IndirectMayWriteSideEffect' is missing an expected operand with tag 'Address' in function '$@'. | ir.cpp:799:6:799:25 | IR: HierarchyConversions | void HierarchyConversions() | +| ir.cpp:810:7:810:26 | IndirectMayWriteSideEffect: call to Base | Instruction 'IndirectMayWriteSideEffect' is missing an expected operand with tag 'Address' in function '$@'. | ir.cpp:799:6:799:25 | IR: HierarchyConversions | void HierarchyConversions() | +| ir.cpp:823:7:823:13 | IndirectMayWriteSideEffect: call to Base | Instruction 'IndirectMayWriteSideEffect' is missing an expected operand with tag 'Address' in function '$@'. | ir.cpp:799:6:799:25 | IR: HierarchyConversions | void HierarchyConversions() | +| ir.cpp:824:7:824:26 | IndirectMayWriteSideEffect: call to Base | Instruction 'IndirectMayWriteSideEffect' is missing an expected operand with tag 'Address' in function '$@'. | ir.cpp:799:6:799:25 | IR: HierarchyConversions | void HierarchyConversions() | +unexpectedOperand +duplicateOperand +missingPhiOperand +missingOperandType +duplicateChiOperand +sideEffectWithoutPrimary +instructionWithoutSuccessor +ambiguousSuccessors +unexplainedLoop +unnecessaryPhiInstruction +operandAcrossFunctions +instructionWithoutUniqueBlock +containsLoopOfForwardEdges +lostReachability +backEdgeCountMismatch +useNotDominatedByDefinition +missingCanonicalLanguageType +multipleCanonicalLanguageTypes +missingIRType +multipleIRTypes +missingCppType diff --git a/cpp/ql/test/library-tests/ir/ir/aliased_ssa_sanity.qlref b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_sanity_unsound.qlref similarity index 100% rename from cpp/ql/test/library-tests/ir/ir/aliased_ssa_sanity.qlref rename to cpp/ql/test/library-tests/ir/ir/aliased_ssa_sanity_unsound.qlref diff --git a/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ssa_sanity.ql b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ssa_sanity.ql new file mode 100644 index 00000000000..b3962e34648 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ssa_sanity.ql @@ -0,0 +1,2 @@ +import semmle.code.cpp.ir.implementation.aliased_ssa.internal.SSASanity +import semmle.code.cpp.ir.implementation.UseSoundEscapeAnalysis diff --git a/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ssa_sanity_unsound.expected b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ssa_sanity_unsound.expected new file mode 100644 index 00000000000..7c2d1faf639 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ssa_sanity_unsound.expected @@ -0,0 +1,2 @@ +multipleOperandMemoryLocations +missingVirtualVariableForMemoryLocation diff --git a/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ssa_sanity.qlref b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ssa_sanity_unsound.qlref similarity index 100% rename from cpp/ql/test/library-tests/ir/ir/aliased_ssa_ssa_sanity.qlref rename to cpp/ql/test/library-tests/ir/ir/aliased_ssa_ssa_sanity_unsound.qlref diff --git a/cpp/ql/test/library-tests/ir/ir/ir.cpp b/cpp/ql/test/library-tests/ir/ir/ir.cpp index 7ebd2e22aee..6989287d222 100644 --- a/cpp/ql/test/library-tests/ir/ir/ir.cpp +++ b/cpp/ql/test/library-tests/ir/ir/ir.cpp @@ -1166,4 +1166,8 @@ int ModeledCallTarget(int x) { return y; } +String ReturnObjectImpl() { + return String("foo"); +} + // semmle-extractor-options: -std=c++17 --clang 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 94c1a433eb8..2583f634374 100644 --- a/cpp/ql/test/library-tests/ir/ir/raw_ir.expected +++ b/cpp/ql/test/library-tests/ir/ir/raw_ir.expected @@ -3371,15 +3371,16 @@ ir.cpp: # 731| Block 7 # 731| r731_11(glval) = VariableAddress[#throw731:19] : -# 731| r731_12(glval) = FunctionAddress[String] : -# 731| r731_13(glval) = StringConstant["String object"] : -# 731| r731_14(char *) = Convert : r731_13 -# 731| v731_15(void) = Call : func:r731_12, this:r731_11, 0:r731_14 -# 731| mu731_16(unknown) = ^CallSideEffect : ~mu724_3 -# 731| mu731_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r731_11 -# 731| v731_18(void) = ^BufferReadSideEffect[0] : &:r731_14, ~mu724_3 -# 731| mu731_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r731_14 -# 731| v731_20(void) = ThrowValue : &:r731_11, ~mu724_3 +# 731| mu731_12(String) = Uninitialized[#throw731:19] : &:r731_11 +# 731| r731_13(glval) = FunctionAddress[String] : +# 731| r731_14(glval) = StringConstant["String object"] : +# 731| r731_15(char *) = Convert : r731_14 +# 731| v731_16(void) = Call : func:r731_13, this:r731_11, 0:r731_15 +# 731| mu731_17(unknown) = ^CallSideEffect : ~mu724_3 +# 731| mu731_18(String) = ^IndirectMayWriteSideEffect[-1] : &:r731_11 +# 731| v731_19(void) = ^BufferReadSideEffect[0] : &:r731_15, ~mu724_3 +# 731| mu731_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r731_15 +# 731| v731_21(void) = ThrowValue : &:r731_11, ~mu724_3 #-----| Exception -> Block 9 # 733| Block 8 @@ -3399,15 +3400,16 @@ ir.cpp: # 735| r735_4(char *) = Load : &:r735_2, ~mu735_3 # 735| mu735_5(unknown) = InitializeIndirection[s] : &:r735_4 # 736| r736_1(glval) = VariableAddress[#throw736:5] : -# 736| r736_2(glval) = FunctionAddress[String] : -# 736| r736_3(glval) = VariableAddress[s] : -# 736| r736_4(char *) = Load : &:r736_3, ~mu724_3 -# 736| v736_5(void) = Call : func:r736_2, this:r736_1, 0:r736_4 -# 736| mu736_6(unknown) = ^CallSideEffect : ~mu724_3 -# 736| mu736_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r736_1 -# 736| v736_8(void) = ^BufferReadSideEffect[0] : &:r736_4, ~mu724_3 -# 736| mu736_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r736_4 -# 736| v736_10(void) = ThrowValue : &:r736_1, ~mu724_3 +# 736| mu736_2(String) = Uninitialized[#throw736:5] : &:r736_1 +# 736| r736_3(glval) = FunctionAddress[String] : +# 736| r736_4(glval) = VariableAddress[s] : +# 736| r736_5(char *) = Load : &:r736_4, ~mu724_3 +# 736| v736_6(void) = Call : func:r736_3, this:r736_1, 0:r736_5 +# 736| mu736_7(unknown) = ^CallSideEffect : ~mu724_3 +# 736| mu736_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r736_1 +# 736| v736_9(void) = ^BufferReadSideEffect[0] : &:r736_5, ~mu724_3 +# 736| mu736_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r736_5 +# 736| v736_11(void) = ThrowValue : &:r736_1, ~mu724_3 #-----| Exception -> Block 2 # 738| Block 11 @@ -5728,15 +5730,16 @@ ir.cpp: # 1140| Block 7 # 1140| r1140_11(glval) = VariableAddress[#throw1140:19] : -# 1140| r1140_12(glval) = FunctionAddress[String] : -# 1140| r1140_13(glval) = StringConstant["String object"] : -# 1140| r1140_14(char *) = Convert : r1140_13 -# 1140| v1140_15(void) = Call : func:r1140_12, this:r1140_11, 0:r1140_14 -# 1140| mu1140_16(unknown) = ^CallSideEffect : ~mu1133_3 -# 1140| mu1140_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r1140_11 -# 1140| v1140_18(void) = ^BufferReadSideEffect[0] : &:r1140_14, ~mu1133_3 -# 1140| mu1140_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r1140_14 -# 1140| v1140_20(void) = ThrowValue : &:r1140_11, ~mu1133_3 +# 1140| mu1140_12(String) = Uninitialized[#throw1140:19] : &:r1140_11 +# 1140| r1140_13(glval) = FunctionAddress[String] : +# 1140| r1140_14(glval) = StringConstant["String object"] : +# 1140| r1140_15(char *) = Convert : r1140_14 +# 1140| v1140_16(void) = Call : func:r1140_13, this:r1140_11, 0:r1140_15 +# 1140| mu1140_17(unknown) = ^CallSideEffect : ~mu1133_3 +# 1140| mu1140_18(String) = ^IndirectMayWriteSideEffect[-1] : &:r1140_11 +# 1140| v1140_19(void) = ^BufferReadSideEffect[0] : &:r1140_15, ~mu1133_3 +# 1140| mu1140_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r1140_15 +# 1140| v1140_21(void) = ThrowValue : &:r1140_11, ~mu1133_3 #-----| Exception -> Block 9 # 1142| Block 8 @@ -5756,15 +5759,16 @@ ir.cpp: # 1144| r1144_4(char *) = Load : &:r1144_2, ~mu1144_3 # 1144| mu1144_5(unknown) = InitializeIndirection[s] : &:r1144_4 # 1145| r1145_1(glval) = VariableAddress[#throw1145:5] : -# 1145| r1145_2(glval) = FunctionAddress[String] : -# 1145| r1145_3(glval) = VariableAddress[s] : -# 1145| r1145_4(char *) = Load : &:r1145_3, ~mu1133_3 -# 1145| v1145_5(void) = Call : func:r1145_2, this:r1145_1, 0:r1145_4 -# 1145| mu1145_6(unknown) = ^CallSideEffect : ~mu1133_3 -# 1145| mu1145_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r1145_1 -# 1145| v1145_8(void) = ^BufferReadSideEffect[0] : &:r1145_4, ~mu1133_3 -# 1145| mu1145_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r1145_4 -# 1145| v1145_10(void) = ThrowValue : &:r1145_1, ~mu1133_3 +# 1145| mu1145_2(String) = Uninitialized[#throw1145:5] : &:r1145_1 +# 1145| r1145_3(glval) = FunctionAddress[String] : +# 1145| r1145_4(glval) = VariableAddress[s] : +# 1145| r1145_5(char *) = Load : &:r1145_4, ~mu1133_3 +# 1145| v1145_6(void) = Call : func:r1145_3, this:r1145_1, 0:r1145_5 +# 1145| mu1145_7(unknown) = ^CallSideEffect : ~mu1133_3 +# 1145| mu1145_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r1145_1 +# 1145| v1145_9(void) = ^BufferReadSideEffect[0] : &:r1145_5, ~mu1133_3 +# 1145| mu1145_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r1145_5 +# 1145| v1145_11(void) = ThrowValue : &:r1145_1, ~mu1133_3 #-----| Exception -> Block 2 # 1147| Block 11 @@ -5878,6 +5882,27 @@ ir.cpp: # 1163| v1163_9(void) = AliasedUse : ~mu1163_3 # 1163| v1163_10(void) = ExitFunction : +# 1169| String ReturnObjectImpl() +# 1169| Block 0 +# 1169| v1169_1(void) = EnterFunction : +# 1169| mu1169_2(unknown) = AliasedDefinition : +# 1169| mu1169_3(unknown) = UnmodeledDefinition : +# 1170| r1170_1(glval) = VariableAddress[#return] : +# 1170| mu1170_2(String) = Uninitialized[#return] : &:r1170_1 +# 1170| r1170_3(glval) = FunctionAddress[String] : +# 1170| r1170_4(glval) = StringConstant["foo"] : +# 1170| r1170_5(char *) = Convert : r1170_4 +# 1170| r1170_6(String) = Call : func:r1170_3, this:r1170_1, 0:r1170_5 +# 1170| mu1170_7(unknown) = ^CallSideEffect : ~mu1169_3 +# 1170| mu1170_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r1170_1 +# 1170| v1170_9(void) = ^BufferReadSideEffect[0] : &:r1170_5, ~mu1169_3 +# 1170| mu1170_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r1170_5 +# 1169| r1169_4(glval) = VariableAddress[#return] : +# 1169| v1169_5(void) = ReturnValue : &:r1169_4, ~mu1169_3 +# 1169| v1169_6(void) = UnmodeledUse : mu* +# 1169| v1169_7(void) = AliasedUse : ~mu1169_3 +# 1169| v1169_8(void) = ExitFunction : + perf-regression.cpp: # 6| void Big::Big() # 6| Block 0 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 new file mode 100644 index 00000000000..0724fbfafb4 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.expected @@ -0,0 +1,5926 @@ +bad_asts.cpp: +# 9| int Bad::S::MemberFunction(int) +# 9| Block 0 +# 9| v9_1(void) = EnterFunction : +# 9| mu9_2(unknown) = AliasedDefinition : +# 9| mu9_3(unknown) = UnmodeledDefinition : +# 9| r9_4(glval) = InitializeThis : +# 9| r9_5(glval) = VariableAddress[y] : +# 9| m9_6(int) = InitializeParameter[y] : &:r9_5 +# 10| r10_1(glval) = VariableAddress[#return] : +# 10| r10_2(int) = Constant[6] : +#-----| r0_1(S *) = CopyValue : r9_4 +# 10| r10_3(glval) = FieldAddress[x] : r0_1 +# 10| r10_4(int) = Load : &:r10_3, ~mu9_3 +# 10| r10_5(int) = Add : r10_2, r10_4 +# 10| r10_6(glval) = VariableAddress[y] : +# 10| r10_7(int) = Load : &:r10_6, m9_6 +# 10| r10_8(int) = Add : r10_5, r10_7 +# 10| m10_9(int) = Store : &:r10_1, r10_8 +# 9| r9_7(glval) = VariableAddress[#return] : +# 9| v9_8(void) = ReturnValue : &:r9_7, m10_9 +# 9| v9_9(void) = UnmodeledUse : mu* +# 9| v9_10(void) = AliasedUse : ~mu9_3 +# 9| v9_11(void) = ExitFunction : + +# 14| void Bad::CallBadMemberFunction() +# 14| Block 0 +# 14| v14_1(void) = EnterFunction : +# 14| mu14_2(unknown) = AliasedDefinition : +# 14| mu14_3(unknown) = UnmodeledDefinition : +# 15| r15_1(glval) = VariableAddress[s] : +# 15| mu15_2(S) = Uninitialized[s] : &:r15_1 +# 15| r15_3(glval) = FieldAddress[x] : r15_1 +# 15| r15_4(int) = Constant[0] : +# 15| mu15_5(int) = Store : &:r15_3, r15_4 +# 16| r16_1(glval) = VariableAddress[s] : +# 16| r16_2(glval) = FunctionAddress[MemberFunction] : +# 16| r16_3(int) = Constant[1] : +# 16| r16_4(int) = Call : func:r16_2, this:r16_1, 0:r16_3 +# 16| mu16_5(unknown) = ^CallSideEffect : ~mu14_3 +# 16| v16_6(void) = ^BufferReadSideEffect[-1] : &:r16_1, ~mu14_3 +# 16| mu16_7(S) = ^IndirectMayWriteSideEffect[-1] : &:r16_1 +# 17| v17_1(void) = NoOp : +# 14| v14_4(void) = ReturnVoid : +# 14| v14_5(void) = UnmodeledUse : mu* +# 14| v14_6(void) = AliasedUse : ~mu14_3 +# 14| v14_7(void) = ExitFunction : + +# 22| void Bad::Point::Point() +# 22| Block 0 +# 22| v22_1(void) = EnterFunction : +# 22| mu22_2(unknown) = AliasedDefinition : +# 22| mu22_3(unknown) = UnmodeledDefinition : +# 22| r22_4(glval) = InitializeThis : +# 23| v23_1(void) = NoOp : +# 22| v22_5(void) = ReturnVoid : +# 22| v22_6(void) = UnmodeledUse : mu* +# 22| v22_7(void) = AliasedUse : ~mu22_3 +# 22| v22_8(void) = ExitFunction : + +# 26| void Bad::CallCopyConstructor(Bad::Point const&) +# 26| Block 0 +# 26| v26_1(void) = EnterFunction : +# 26| mu26_2(unknown) = AliasedDefinition : +# 26| mu26_3(unknown) = UnmodeledDefinition : +# 26| r26_4(glval) = VariableAddress[a] : +# 26| m26_5(Point &) = InitializeParameter[a] : &:r26_4 +# 26| r26_6(Point &) = Load : &:r26_4, m26_5 +# 26| mu26_7(unknown) = InitializeIndirection[a] : &:r26_6 +# 27| r27_1(glval) = VariableAddress[b] : +# 27| r27_2(glval) = VariableAddress[a] : +# 27| r27_3(Point &) = Load : &:r27_2, m26_5 +# 27| r27_4(glval) = CopyValue : r27_3 +# 27| r27_5(glval) = Convert : r27_4 +# 27| r27_6(Point) = Load : &:r27_5, ~mu26_3 +# 27| m27_7(Point) = Store : &:r27_1, r27_6 +# 28| v28_1(void) = NoOp : +# 26| v26_8(void) = ReturnIndirection : &:r26_6, ~mu26_3 +# 26| v26_9(void) = ReturnVoid : +# 26| v26_10(void) = UnmodeledUse : mu* +# 26| v26_11(void) = AliasedUse : ~mu26_3 +# 26| v26_12(void) = ExitFunction : + +# 30| void Bad::errorExpr() +# 30| Block 0 +# 30| v30_1(void) = EnterFunction : +# 30| mu30_2(unknown) = AliasedDefinition : +# 30| mu30_3(unknown) = UnmodeledDefinition : +# 31| r31_1(glval) = VariableAddress[intref] : +# 31| r31_2(error) = Error : +# 31| m31_3(int &) = Store : &:r31_1, r31_2 +# 32| r32_1(glval) = VariableAddress[x] : +# 32| r32_2(error) = Error : +# 32| m32_3(int) = Store : &:r32_1, r32_2 +#-----| r0_1(glval) = Error : +#-----| r0_2(error) = Load : &:r0_1, ~mu30_3 +# 33| r33_1(glval) = VariableAddress[x] : +# 33| m33_2(int) = Store : &:r33_1, r0_2 +# 34| v34_1(void) = NoOp : +# 30| v30_4(void) = ReturnVoid : +# 30| v30_5(void) = UnmodeledUse : mu* +# 30| v30_6(void) = AliasedUse : ~mu30_3 +# 30| v30_7(void) = ExitFunction : + +clang.cpp: +# 5| int* globalIntAddress() +# 5| Block 0 +# 5| v5_1(void) = EnterFunction : +# 5| mu5_2(unknown) = AliasedDefinition : +# 5| mu5_3(unknown) = UnmodeledDefinition : +# 6| r6_1(glval) = VariableAddress[#return] : +# 6| r6_2(glval) = VariableAddress[globalInt] : +# 6| r6_3(int *) = CopyValue : r6_2 +# 6| m6_4(int *) = Store : &:r6_1, r6_3 +# 5| r5_4(glval) = VariableAddress[#return] : +# 5| v5_5(void) = ReturnValue : &:r5_4, m6_4 +# 5| v5_6(void) = UnmodeledUse : mu* +# 5| v5_7(void) = AliasedUse : ~mu5_3 +# 5| v5_8(void) = ExitFunction : + +ir.cpp: +# 1| void Constants() +# 1| Block 0 +# 1| v1_1(void) = EnterFunction : +# 1| mu1_2(unknown) = AliasedDefinition : +# 1| mu1_3(unknown) = UnmodeledDefinition : +# 2| r2_1(glval) = VariableAddress[c_i] : +# 2| r2_2(char) = Constant[1] : +# 2| m2_3(char) = Store : &:r2_1, r2_2 +# 3| r3_1(glval) = VariableAddress[c_c] : +# 3| r3_2(char) = Constant[65] : +# 3| m3_3(char) = Store : &:r3_1, r3_2 +# 5| r5_1(glval) = VariableAddress[sc_i] : +# 5| r5_2(signed char) = Constant[-1] : +# 5| m5_3(signed char) = Store : &:r5_1, r5_2 +# 6| r6_1(glval) = VariableAddress[sc_c] : +# 6| r6_2(signed char) = Constant[65] : +# 6| m6_3(signed char) = Store : &:r6_1, r6_2 +# 8| r8_1(glval) = VariableAddress[uc_i] : +# 8| r8_2(unsigned char) = Constant[5] : +# 8| m8_3(unsigned char) = Store : &:r8_1, r8_2 +# 9| r9_1(glval) = VariableAddress[uc_c] : +# 9| r9_2(unsigned char) = Constant[65] : +# 9| m9_3(unsigned char) = Store : &:r9_1, r9_2 +# 11| r11_1(glval) = VariableAddress[s] : +# 11| r11_2(short) = Constant[5] : +# 11| m11_3(short) = Store : &:r11_1, r11_2 +# 12| r12_1(glval) = VariableAddress[us] : +# 12| r12_2(unsigned short) = Constant[5] : +# 12| m12_3(unsigned short) = Store : &:r12_1, r12_2 +# 14| r14_1(glval) = VariableAddress[i] : +# 14| r14_2(int) = Constant[5] : +# 14| m14_3(int) = Store : &:r14_1, r14_2 +# 15| r15_1(glval) = VariableAddress[ui] : +# 15| r15_2(unsigned int) = Constant[5] : +# 15| m15_3(unsigned int) = Store : &:r15_1, r15_2 +# 17| r17_1(glval) = VariableAddress[l] : +# 17| r17_2(long) = Constant[5] : +# 17| m17_3(long) = Store : &:r17_1, r17_2 +# 18| r18_1(glval) = VariableAddress[ul] : +# 18| r18_2(unsigned long) = Constant[5] : +# 18| m18_3(unsigned long) = Store : &:r18_1, r18_2 +# 20| r20_1(glval) = VariableAddress[ll_i] : +# 20| r20_2(long long) = Constant[5] : +# 20| m20_3(long long) = Store : &:r20_1, r20_2 +# 21| r21_1(glval) = VariableAddress[ll_ll] : +# 21| r21_2(long long) = Constant[5] : +# 21| m21_3(long long) = Store : &:r21_1, r21_2 +# 22| r22_1(glval) = VariableAddress[ull_i] : +# 22| r22_2(unsigned long long) = Constant[5] : +# 22| m22_3(unsigned long long) = Store : &:r22_1, r22_2 +# 23| r23_1(glval) = VariableAddress[ull_ull] : +# 23| r23_2(unsigned long long) = Constant[5] : +# 23| m23_3(unsigned long long) = Store : &:r23_1, r23_2 +# 25| r25_1(glval) = VariableAddress[b_t] : +# 25| r25_2(bool) = Constant[1] : +# 25| m25_3(bool) = Store : &:r25_1, r25_2 +# 26| r26_1(glval) = VariableAddress[b_f] : +# 26| r26_2(bool) = Constant[0] : +# 26| m26_3(bool) = Store : &:r26_1, r26_2 +# 28| r28_1(glval) = VariableAddress[wc_i] : +# 28| r28_2(wchar_t) = Constant[5] : +# 28| m28_3(wchar_t) = Store : &:r28_1, r28_2 +# 29| r29_1(glval) = VariableAddress[wc_c] : +# 29| r29_2(wchar_t) = Constant[65] : +# 29| m29_3(wchar_t) = Store : &:r29_1, r29_2 +# 31| r31_1(glval) = VariableAddress[c16] : +# 31| r31_2(char16_t) = Constant[65] : +# 31| m31_3(char16_t) = Store : &:r31_1, r31_2 +# 32| r32_1(glval) = VariableAddress[c32] : +# 32| r32_2(char32_t) = Constant[65] : +# 32| m32_3(char32_t) = Store : &:r32_1, r32_2 +# 34| r34_1(glval) = VariableAddress[f_i] : +# 34| r34_2(float) = Constant[1.0] : +# 34| m34_3(float) = Store : &:r34_1, r34_2 +# 35| r35_1(glval) = VariableAddress[f_f] : +# 35| r35_2(float) = Constant[1.0] : +# 35| m35_3(float) = Store : &:r35_1, r35_2 +# 36| r36_1(glval) = VariableAddress[f_d] : +# 36| r36_2(float) = Constant[1.0] : +# 36| m36_3(float) = Store : &:r36_1, r36_2 +# 38| r38_1(glval) = VariableAddress[d_i] : +# 38| r38_2(double) = Constant[1.0] : +# 38| m38_3(double) = Store : &:r38_1, r38_2 +# 39| r39_1(glval) = VariableAddress[d_f] : +# 39| r39_2(double) = Constant[1.0] : +# 39| m39_3(double) = Store : &:r39_1, r39_2 +# 40| r40_1(glval) = VariableAddress[d_d] : +# 40| r40_2(double) = Constant[1.0] : +# 40| m40_3(double) = Store : &:r40_1, r40_2 +# 41| v41_1(void) = NoOp : +# 1| v1_4(void) = ReturnVoid : +# 1| v1_5(void) = UnmodeledUse : mu* +# 1| v1_6(void) = AliasedUse : ~mu1_3 +# 1| v1_7(void) = ExitFunction : + +# 43| void Foo() +# 43| Block 0 +# 43| v43_1(void) = EnterFunction : +# 43| mu43_2(unknown) = AliasedDefinition : +# 43| mu43_3(unknown) = UnmodeledDefinition : +# 44| r44_1(glval) = VariableAddress[x] : +# 44| r44_2(int) = Constant[17] : +# 44| m44_3(int) = Store : &:r44_1, r44_2 +# 45| r45_1(glval) = VariableAddress[y] : +# 45| r45_2(short) = Constant[7] : +# 45| m45_3(short) = Store : &:r45_1, r45_2 +# 46| r46_1(glval) = VariableAddress[x] : +# 46| r46_2(int) = Load : &:r46_1, m44_3 +# 46| r46_3(glval) = VariableAddress[y] : +# 46| r46_4(short) = Load : &:r46_3, m45_3 +# 46| r46_5(int) = Convert : r46_4 +# 46| r46_6(int) = Add : r46_2, r46_5 +# 46| r46_7(short) = Convert : r46_6 +# 46| r46_8(glval) = VariableAddress[y] : +# 46| m46_9(short) = Store : &:r46_8, r46_7 +# 47| r47_1(glval) = VariableAddress[x] : +# 47| r47_2(int) = Load : &:r47_1, m44_3 +# 47| r47_3(glval) = VariableAddress[y] : +# 47| r47_4(short) = Load : &:r47_3, m46_9 +# 47| r47_5(int) = Convert : r47_4 +# 47| r47_6(int) = Mul : r47_2, r47_5 +# 47| r47_7(glval) = VariableAddress[x] : +# 47| m47_8(int) = Store : &:r47_7, r47_6 +# 48| v48_1(void) = NoOp : +# 43| v43_4(void) = ReturnVoid : +# 43| v43_5(void) = UnmodeledUse : mu* +# 43| v43_6(void) = AliasedUse : ~mu43_3 +# 43| v43_7(void) = ExitFunction : + +# 50| void IntegerOps(int, int) +# 50| Block 0 +# 50| v50_1(void) = EnterFunction : +# 50| mu50_2(unknown) = AliasedDefinition : +# 50| mu50_3(unknown) = UnmodeledDefinition : +# 50| r50_4(glval) = VariableAddress[x] : +# 50| m50_5(int) = InitializeParameter[x] : &:r50_4 +# 50| r50_6(glval) = VariableAddress[y] : +# 50| m50_7(int) = InitializeParameter[y] : &:r50_6 +# 51| r51_1(glval) = VariableAddress[z] : +# 51| m51_2(int) = Uninitialized[z] : &:r51_1 +# 53| r53_1(glval) = VariableAddress[x] : +# 53| r53_2(int) = Load : &:r53_1, m50_5 +# 53| r53_3(glval) = VariableAddress[y] : +# 53| r53_4(int) = Load : &:r53_3, m50_7 +# 53| r53_5(int) = Add : r53_2, r53_4 +# 53| r53_6(glval) = VariableAddress[z] : +# 53| m53_7(int) = Store : &:r53_6, r53_5 +# 54| r54_1(glval) = VariableAddress[x] : +# 54| r54_2(int) = Load : &:r54_1, m50_5 +# 54| r54_3(glval) = VariableAddress[y] : +# 54| r54_4(int) = Load : &:r54_3, m50_7 +# 54| r54_5(int) = Sub : r54_2, r54_4 +# 54| r54_6(glval) = VariableAddress[z] : +# 54| m54_7(int) = Store : &:r54_6, r54_5 +# 55| r55_1(glval) = VariableAddress[x] : +# 55| r55_2(int) = Load : &:r55_1, m50_5 +# 55| r55_3(glval) = VariableAddress[y] : +# 55| r55_4(int) = Load : &:r55_3, m50_7 +# 55| r55_5(int) = Mul : r55_2, r55_4 +# 55| r55_6(glval) = VariableAddress[z] : +# 55| m55_7(int) = Store : &:r55_6, r55_5 +# 56| r56_1(glval) = VariableAddress[x] : +# 56| r56_2(int) = Load : &:r56_1, m50_5 +# 56| r56_3(glval) = VariableAddress[y] : +# 56| r56_4(int) = Load : &:r56_3, m50_7 +# 56| r56_5(int) = Div : r56_2, r56_4 +# 56| r56_6(glval) = VariableAddress[z] : +# 56| m56_7(int) = Store : &:r56_6, r56_5 +# 57| r57_1(glval) = VariableAddress[x] : +# 57| r57_2(int) = Load : &:r57_1, m50_5 +# 57| r57_3(glval) = VariableAddress[y] : +# 57| r57_4(int) = Load : &:r57_3, m50_7 +# 57| r57_5(int) = Rem : r57_2, r57_4 +# 57| r57_6(glval) = VariableAddress[z] : +# 57| m57_7(int) = Store : &:r57_6, r57_5 +# 59| r59_1(glval) = VariableAddress[x] : +# 59| r59_2(int) = Load : &:r59_1, m50_5 +# 59| r59_3(glval) = VariableAddress[y] : +# 59| r59_4(int) = Load : &:r59_3, m50_7 +# 59| r59_5(int) = BitAnd : r59_2, r59_4 +# 59| r59_6(glval) = VariableAddress[z] : +# 59| m59_7(int) = Store : &:r59_6, r59_5 +# 60| r60_1(glval) = VariableAddress[x] : +# 60| r60_2(int) = Load : &:r60_1, m50_5 +# 60| r60_3(glval) = VariableAddress[y] : +# 60| r60_4(int) = Load : &:r60_3, m50_7 +# 60| r60_5(int) = BitOr : r60_2, r60_4 +# 60| r60_6(glval) = VariableAddress[z] : +# 60| m60_7(int) = Store : &:r60_6, r60_5 +# 61| r61_1(glval) = VariableAddress[x] : +# 61| r61_2(int) = Load : &:r61_1, m50_5 +# 61| r61_3(glval) = VariableAddress[y] : +# 61| r61_4(int) = Load : &:r61_3, m50_7 +# 61| r61_5(int) = BitXor : r61_2, r61_4 +# 61| r61_6(glval) = VariableAddress[z] : +# 61| m61_7(int) = Store : &:r61_6, r61_5 +# 63| r63_1(glval) = VariableAddress[x] : +# 63| r63_2(int) = Load : &:r63_1, m50_5 +# 63| r63_3(glval) = VariableAddress[y] : +# 63| r63_4(int) = Load : &:r63_3, m50_7 +# 63| r63_5(int) = ShiftLeft : r63_2, r63_4 +# 63| r63_6(glval) = VariableAddress[z] : +# 63| m63_7(int) = Store : &:r63_6, r63_5 +# 64| r64_1(glval) = VariableAddress[x] : +# 64| r64_2(int) = Load : &:r64_1, m50_5 +# 64| r64_3(glval) = VariableAddress[y] : +# 64| r64_4(int) = Load : &:r64_3, m50_7 +# 64| r64_5(int) = ShiftRight : r64_2, r64_4 +# 64| r64_6(glval) = VariableAddress[z] : +# 64| m64_7(int) = Store : &:r64_6, r64_5 +# 66| r66_1(glval) = VariableAddress[x] : +# 66| r66_2(int) = Load : &:r66_1, m50_5 +# 66| r66_3(glval) = VariableAddress[z] : +# 66| m66_4(int) = Store : &:r66_3, r66_2 +# 68| r68_1(glval) = VariableAddress[x] : +# 68| r68_2(int) = Load : &:r68_1, m50_5 +# 68| r68_3(glval) = VariableAddress[z] : +# 68| r68_4(int) = Load : &:r68_3, m66_4 +# 68| r68_5(int) = Add : r68_4, r68_2 +# 68| m68_6(int) = Store : &:r68_3, r68_5 +# 69| r69_1(glval) = VariableAddress[x] : +# 69| r69_2(int) = Load : &:r69_1, m50_5 +# 69| r69_3(glval) = VariableAddress[z] : +# 69| r69_4(int) = Load : &:r69_3, m68_6 +# 69| r69_5(int) = Sub : r69_4, r69_2 +# 69| m69_6(int) = Store : &:r69_3, r69_5 +# 70| r70_1(glval) = VariableAddress[x] : +# 70| r70_2(int) = Load : &:r70_1, m50_5 +# 70| r70_3(glval) = VariableAddress[z] : +# 70| r70_4(int) = Load : &:r70_3, m69_6 +# 70| r70_5(int) = Mul : r70_4, r70_2 +# 70| m70_6(int) = Store : &:r70_3, r70_5 +# 71| r71_1(glval) = VariableAddress[x] : +# 71| r71_2(int) = Load : &:r71_1, m50_5 +# 71| r71_3(glval) = VariableAddress[z] : +# 71| r71_4(int) = Load : &:r71_3, m70_6 +# 71| r71_5(int) = Div : r71_4, r71_2 +# 71| m71_6(int) = Store : &:r71_3, r71_5 +# 72| r72_1(glval) = VariableAddress[x] : +# 72| r72_2(int) = Load : &:r72_1, m50_5 +# 72| r72_3(glval) = VariableAddress[z] : +# 72| r72_4(int) = Load : &:r72_3, m71_6 +# 72| r72_5(int) = Rem : r72_4, r72_2 +# 72| m72_6(int) = Store : &:r72_3, r72_5 +# 74| r74_1(glval) = VariableAddress[x] : +# 74| r74_2(int) = Load : &:r74_1, m50_5 +# 74| r74_3(glval) = VariableAddress[z] : +# 74| r74_4(int) = Load : &:r74_3, m72_6 +# 74| r74_5(int) = BitAnd : r74_4, r74_2 +# 74| m74_6(int) = Store : &:r74_3, r74_5 +# 75| r75_1(glval) = VariableAddress[x] : +# 75| r75_2(int) = Load : &:r75_1, m50_5 +# 75| r75_3(glval) = VariableAddress[z] : +# 75| r75_4(int) = Load : &:r75_3, m74_6 +# 75| r75_5(int) = BitOr : r75_4, r75_2 +# 75| m75_6(int) = Store : &:r75_3, r75_5 +# 76| r76_1(glval) = VariableAddress[x] : +# 76| r76_2(int) = Load : &:r76_1, m50_5 +# 76| r76_3(glval) = VariableAddress[z] : +# 76| r76_4(int) = Load : &:r76_3, m75_6 +# 76| r76_5(int) = BitXor : r76_4, r76_2 +# 76| m76_6(int) = Store : &:r76_3, r76_5 +# 78| r78_1(glval) = VariableAddress[x] : +# 78| r78_2(int) = Load : &:r78_1, m50_5 +# 78| r78_3(glval) = VariableAddress[z] : +# 78| r78_4(int) = Load : &:r78_3, m76_6 +# 78| r78_5(int) = ShiftLeft : r78_4, r78_2 +# 78| m78_6(int) = Store : &:r78_3, r78_5 +# 79| r79_1(glval) = VariableAddress[x] : +# 79| r79_2(int) = Load : &:r79_1, m50_5 +# 79| r79_3(glval) = VariableAddress[z] : +# 79| r79_4(int) = Load : &:r79_3, m78_6 +# 79| r79_5(int) = ShiftRight : r79_4, r79_2 +# 79| m79_6(int) = Store : &:r79_3, r79_5 +# 81| r81_1(glval) = VariableAddress[x] : +# 81| r81_2(int) = Load : &:r81_1, m50_5 +# 81| r81_3(int) = CopyValue : r81_2 +# 81| r81_4(glval) = VariableAddress[z] : +# 81| m81_5(int) = Store : &:r81_4, r81_3 +# 82| r82_1(glval) = VariableAddress[x] : +# 82| r82_2(int) = Load : &:r82_1, m50_5 +# 82| r82_3(int) = Negate : r82_2 +# 82| r82_4(glval) = VariableAddress[z] : +# 82| m82_5(int) = Store : &:r82_4, r82_3 +# 83| r83_1(glval) = VariableAddress[x] : +# 83| r83_2(int) = Load : &:r83_1, m50_5 +# 83| r83_3(int) = BitComplement : r83_2 +# 83| r83_4(glval) = VariableAddress[z] : +# 83| m83_5(int) = Store : &:r83_4, r83_3 +# 84| r84_1(glval) = VariableAddress[x] : +# 84| r84_2(int) = Load : &:r84_1, m50_5 +# 84| r84_3(int) = Constant[0] : +# 84| r84_4(bool) = CompareNE : r84_2, r84_3 +# 84| r84_5(bool) = LogicalNot : r84_4 +# 84| r84_6(int) = Convert : r84_5 +# 84| r84_7(glval) = VariableAddress[z] : +# 84| m84_8(int) = Store : &:r84_7, r84_6 +# 85| v85_1(void) = NoOp : +# 50| v50_8(void) = ReturnVoid : +# 50| v50_9(void) = UnmodeledUse : mu* +# 50| v50_10(void) = AliasedUse : ~mu50_3 +# 50| v50_11(void) = ExitFunction : + +# 87| void IntegerCompare(int, int) +# 87| Block 0 +# 87| v87_1(void) = EnterFunction : +# 87| mu87_2(unknown) = AliasedDefinition : +# 87| mu87_3(unknown) = UnmodeledDefinition : +# 87| r87_4(glval) = VariableAddress[x] : +# 87| m87_5(int) = InitializeParameter[x] : &:r87_4 +# 87| r87_6(glval) = VariableAddress[y] : +# 87| m87_7(int) = InitializeParameter[y] : &:r87_6 +# 88| r88_1(glval) = VariableAddress[b] : +# 88| m88_2(bool) = Uninitialized[b] : &:r88_1 +# 90| r90_1(glval) = VariableAddress[x] : +# 90| r90_2(int) = Load : &:r90_1, m87_5 +# 90| r90_3(glval) = VariableAddress[y] : +# 90| r90_4(int) = Load : &:r90_3, m87_7 +# 90| r90_5(bool) = CompareEQ : r90_2, r90_4 +# 90| r90_6(glval) = VariableAddress[b] : +# 90| m90_7(bool) = Store : &:r90_6, r90_5 +# 91| r91_1(glval) = VariableAddress[x] : +# 91| r91_2(int) = Load : &:r91_1, m87_5 +# 91| r91_3(glval) = VariableAddress[y] : +# 91| r91_4(int) = Load : &:r91_3, m87_7 +# 91| r91_5(bool) = CompareNE : r91_2, r91_4 +# 91| r91_6(glval) = VariableAddress[b] : +# 91| m91_7(bool) = Store : &:r91_6, r91_5 +# 92| r92_1(glval) = VariableAddress[x] : +# 92| r92_2(int) = Load : &:r92_1, m87_5 +# 92| r92_3(glval) = VariableAddress[y] : +# 92| r92_4(int) = Load : &:r92_3, m87_7 +# 92| r92_5(bool) = CompareLT : r92_2, r92_4 +# 92| r92_6(glval) = VariableAddress[b] : +# 92| m92_7(bool) = Store : &:r92_6, r92_5 +# 93| r93_1(glval) = VariableAddress[x] : +# 93| r93_2(int) = Load : &:r93_1, m87_5 +# 93| r93_3(glval) = VariableAddress[y] : +# 93| r93_4(int) = Load : &:r93_3, m87_7 +# 93| r93_5(bool) = CompareGT : r93_2, r93_4 +# 93| r93_6(glval) = VariableAddress[b] : +# 93| m93_7(bool) = Store : &:r93_6, r93_5 +# 94| r94_1(glval) = VariableAddress[x] : +# 94| r94_2(int) = Load : &:r94_1, m87_5 +# 94| r94_3(glval) = VariableAddress[y] : +# 94| r94_4(int) = Load : &:r94_3, m87_7 +# 94| r94_5(bool) = CompareLE : r94_2, r94_4 +# 94| r94_6(glval) = VariableAddress[b] : +# 94| m94_7(bool) = Store : &:r94_6, r94_5 +# 95| r95_1(glval) = VariableAddress[x] : +# 95| r95_2(int) = Load : &:r95_1, m87_5 +# 95| r95_3(glval) = VariableAddress[y] : +# 95| r95_4(int) = Load : &:r95_3, m87_7 +# 95| r95_5(bool) = CompareGE : r95_2, r95_4 +# 95| r95_6(glval) = VariableAddress[b] : +# 95| m95_7(bool) = Store : &:r95_6, r95_5 +# 96| v96_1(void) = NoOp : +# 87| v87_8(void) = ReturnVoid : +# 87| v87_9(void) = UnmodeledUse : mu* +# 87| v87_10(void) = AliasedUse : ~mu87_3 +# 87| v87_11(void) = ExitFunction : + +# 98| void IntegerCrement(int) +# 98| Block 0 +# 98| v98_1(void) = EnterFunction : +# 98| mu98_2(unknown) = AliasedDefinition : +# 98| mu98_3(unknown) = UnmodeledDefinition : +# 98| r98_4(glval) = VariableAddress[x] : +# 98| m98_5(int) = InitializeParameter[x] : &:r98_4 +# 99| r99_1(glval) = VariableAddress[y] : +# 99| m99_2(int) = Uninitialized[y] : &:r99_1 +# 101| r101_1(glval) = VariableAddress[x] : +# 101| r101_2(int) = Load : &:r101_1, m98_5 +# 101| r101_3(int) = Constant[1] : +# 101| r101_4(int) = Add : r101_2, r101_3 +# 101| m101_5(int) = Store : &:r101_1, r101_4 +# 101| r101_6(glval) = VariableAddress[y] : +# 101| m101_7(int) = Store : &:r101_6, r101_4 +# 102| r102_1(glval) = VariableAddress[x] : +# 102| r102_2(int) = Load : &:r102_1, m101_5 +# 102| r102_3(int) = Constant[1] : +# 102| r102_4(int) = Sub : r102_2, r102_3 +# 102| m102_5(int) = Store : &:r102_1, r102_4 +# 102| r102_6(glval) = VariableAddress[y] : +# 102| m102_7(int) = Store : &:r102_6, r102_4 +# 103| r103_1(glval) = VariableAddress[x] : +# 103| r103_2(int) = Load : &:r103_1, m102_5 +# 103| r103_3(int) = Constant[1] : +# 103| r103_4(int) = Add : r103_2, r103_3 +# 103| m103_5(int) = Store : &:r103_1, r103_4 +# 103| r103_6(glval) = VariableAddress[y] : +# 103| m103_7(int) = Store : &:r103_6, r103_2 +# 104| r104_1(glval) = VariableAddress[x] : +# 104| r104_2(int) = Load : &:r104_1, m103_5 +# 104| r104_3(int) = Constant[1] : +# 104| r104_4(int) = Sub : r104_2, r104_3 +# 104| m104_5(int) = Store : &:r104_1, r104_4 +# 104| r104_6(glval) = VariableAddress[y] : +# 104| m104_7(int) = Store : &:r104_6, r104_2 +# 105| v105_1(void) = NoOp : +# 98| v98_6(void) = ReturnVoid : +# 98| v98_7(void) = UnmodeledUse : mu* +# 98| v98_8(void) = AliasedUse : ~mu98_3 +# 98| v98_9(void) = ExitFunction : + +# 107| void IntegerCrement_LValue(int) +# 107| Block 0 +# 107| v107_1(void) = EnterFunction : +# 107| mu107_2(unknown) = AliasedDefinition : +# 107| mu107_3(unknown) = UnmodeledDefinition : +# 107| r107_4(glval) = VariableAddress[x] : +# 107| m107_5(int) = InitializeParameter[x] : &:r107_4 +# 108| r108_1(glval) = VariableAddress[p] : +# 108| m108_2(int *) = Uninitialized[p] : &:r108_1 +# 110| r110_1(glval) = VariableAddress[x] : +# 110| r110_2(int) = Load : &:r110_1, m107_5 +# 110| r110_3(int) = Constant[1] : +# 110| r110_4(int) = Add : r110_2, r110_3 +# 110| m110_5(int) = Store : &:r110_1, r110_4 +# 110| r110_6(glval) = CopyValue : r110_1 +# 110| r110_7(int *) = CopyValue : r110_6 +# 110| r110_8(glval) = VariableAddress[p] : +# 110| m110_9(int *) = Store : &:r110_8, r110_7 +# 111| r111_1(glval) = VariableAddress[x] : +# 111| r111_2(int) = Load : &:r111_1, m110_5 +# 111| r111_3(int) = Constant[1] : +# 111| r111_4(int) = Sub : r111_2, r111_3 +# 111| m111_5(int) = Store : &:r111_1, r111_4 +# 111| r111_6(glval) = CopyValue : r111_1 +# 111| r111_7(int *) = CopyValue : r111_6 +# 111| r111_8(glval) = VariableAddress[p] : +# 111| m111_9(int *) = Store : &:r111_8, r111_7 +# 112| v112_1(void) = NoOp : +# 107| v107_6(void) = ReturnVoid : +# 107| v107_7(void) = UnmodeledUse : mu* +# 107| v107_8(void) = AliasedUse : ~mu107_3 +# 107| v107_9(void) = ExitFunction : + +# 114| void FloatOps(double, double) +# 114| Block 0 +# 114| v114_1(void) = EnterFunction : +# 114| mu114_2(unknown) = AliasedDefinition : +# 114| mu114_3(unknown) = UnmodeledDefinition : +# 114| r114_4(glval) = VariableAddress[x] : +# 114| m114_5(double) = InitializeParameter[x] : &:r114_4 +# 114| r114_6(glval) = VariableAddress[y] : +# 114| m114_7(double) = InitializeParameter[y] : &:r114_6 +# 115| r115_1(glval) = VariableAddress[z] : +# 115| m115_2(double) = Uninitialized[z] : &:r115_1 +# 117| r117_1(glval) = VariableAddress[x] : +# 117| r117_2(double) = Load : &:r117_1, m114_5 +# 117| r117_3(glval) = VariableAddress[y] : +# 117| r117_4(double) = Load : &:r117_3, m114_7 +# 117| r117_5(double) = Add : r117_2, r117_4 +# 117| r117_6(glval) = VariableAddress[z] : +# 117| m117_7(double) = Store : &:r117_6, r117_5 +# 118| r118_1(glval) = VariableAddress[x] : +# 118| r118_2(double) = Load : &:r118_1, m114_5 +# 118| r118_3(glval) = VariableAddress[y] : +# 118| r118_4(double) = Load : &:r118_3, m114_7 +# 118| r118_5(double) = Sub : r118_2, r118_4 +# 118| r118_6(glval) = VariableAddress[z] : +# 118| m118_7(double) = Store : &:r118_6, r118_5 +# 119| r119_1(glval) = VariableAddress[x] : +# 119| r119_2(double) = Load : &:r119_1, m114_5 +# 119| r119_3(glval) = VariableAddress[y] : +# 119| r119_4(double) = Load : &:r119_3, m114_7 +# 119| r119_5(double) = Mul : r119_2, r119_4 +# 119| r119_6(glval) = VariableAddress[z] : +# 119| m119_7(double) = Store : &:r119_6, r119_5 +# 120| r120_1(glval) = VariableAddress[x] : +# 120| r120_2(double) = Load : &:r120_1, m114_5 +# 120| r120_3(glval) = VariableAddress[y] : +# 120| r120_4(double) = Load : &:r120_3, m114_7 +# 120| r120_5(double) = Div : r120_2, r120_4 +# 120| r120_6(glval) = VariableAddress[z] : +# 120| m120_7(double) = Store : &:r120_6, r120_5 +# 122| r122_1(glval) = VariableAddress[x] : +# 122| r122_2(double) = Load : &:r122_1, m114_5 +# 122| r122_3(glval) = VariableAddress[z] : +# 122| m122_4(double) = Store : &:r122_3, r122_2 +# 124| r124_1(glval) = VariableAddress[x] : +# 124| r124_2(double) = Load : &:r124_1, m114_5 +# 124| r124_3(glval) = VariableAddress[z] : +# 124| r124_4(double) = Load : &:r124_3, m122_4 +# 124| r124_5(double) = Add : r124_4, r124_2 +# 124| m124_6(double) = Store : &:r124_3, r124_5 +# 125| r125_1(glval) = VariableAddress[x] : +# 125| r125_2(double) = Load : &:r125_1, m114_5 +# 125| r125_3(glval) = VariableAddress[z] : +# 125| r125_4(double) = Load : &:r125_3, m124_6 +# 125| r125_5(double) = Sub : r125_4, r125_2 +# 125| m125_6(double) = Store : &:r125_3, r125_5 +# 126| r126_1(glval) = VariableAddress[x] : +# 126| r126_2(double) = Load : &:r126_1, m114_5 +# 126| r126_3(glval) = VariableAddress[z] : +# 126| r126_4(double) = Load : &:r126_3, m125_6 +# 126| r126_5(double) = Mul : r126_4, r126_2 +# 126| m126_6(double) = Store : &:r126_3, r126_5 +# 127| r127_1(glval) = VariableAddress[x] : +# 127| r127_2(double) = Load : &:r127_1, m114_5 +# 127| r127_3(glval) = VariableAddress[z] : +# 127| r127_4(double) = Load : &:r127_3, m126_6 +# 127| r127_5(double) = Div : r127_4, r127_2 +# 127| m127_6(double) = Store : &:r127_3, r127_5 +# 129| r129_1(glval) = VariableAddress[x] : +# 129| r129_2(double) = Load : &:r129_1, m114_5 +# 129| r129_3(double) = CopyValue : r129_2 +# 129| r129_4(glval) = VariableAddress[z] : +# 129| m129_5(double) = Store : &:r129_4, r129_3 +# 130| r130_1(glval) = VariableAddress[x] : +# 130| r130_2(double) = Load : &:r130_1, m114_5 +# 130| r130_3(double) = Negate : r130_2 +# 130| r130_4(glval) = VariableAddress[z] : +# 130| m130_5(double) = Store : &:r130_4, r130_3 +# 131| v131_1(void) = NoOp : +# 114| v114_8(void) = ReturnVoid : +# 114| v114_9(void) = UnmodeledUse : mu* +# 114| v114_10(void) = AliasedUse : ~mu114_3 +# 114| v114_11(void) = ExitFunction : + +# 133| void FloatCompare(double, double) +# 133| Block 0 +# 133| v133_1(void) = EnterFunction : +# 133| mu133_2(unknown) = AliasedDefinition : +# 133| mu133_3(unknown) = UnmodeledDefinition : +# 133| r133_4(glval) = VariableAddress[x] : +# 133| m133_5(double) = InitializeParameter[x] : &:r133_4 +# 133| r133_6(glval) = VariableAddress[y] : +# 133| m133_7(double) = InitializeParameter[y] : &:r133_6 +# 134| r134_1(glval) = VariableAddress[b] : +# 134| m134_2(bool) = Uninitialized[b] : &:r134_1 +# 136| r136_1(glval) = VariableAddress[x] : +# 136| r136_2(double) = Load : &:r136_1, m133_5 +# 136| r136_3(glval) = VariableAddress[y] : +# 136| r136_4(double) = Load : &:r136_3, m133_7 +# 136| r136_5(bool) = CompareEQ : r136_2, r136_4 +# 136| r136_6(glval) = VariableAddress[b] : +# 136| m136_7(bool) = Store : &:r136_6, r136_5 +# 137| r137_1(glval) = VariableAddress[x] : +# 137| r137_2(double) = Load : &:r137_1, m133_5 +# 137| r137_3(glval) = VariableAddress[y] : +# 137| r137_4(double) = Load : &:r137_3, m133_7 +# 137| r137_5(bool) = CompareNE : r137_2, r137_4 +# 137| r137_6(glval) = VariableAddress[b] : +# 137| m137_7(bool) = Store : &:r137_6, r137_5 +# 138| r138_1(glval) = VariableAddress[x] : +# 138| r138_2(double) = Load : &:r138_1, m133_5 +# 138| r138_3(glval) = VariableAddress[y] : +# 138| r138_4(double) = Load : &:r138_3, m133_7 +# 138| r138_5(bool) = CompareLT : r138_2, r138_4 +# 138| r138_6(glval) = VariableAddress[b] : +# 138| m138_7(bool) = Store : &:r138_6, r138_5 +# 139| r139_1(glval) = VariableAddress[x] : +# 139| r139_2(double) = Load : &:r139_1, m133_5 +# 139| r139_3(glval) = VariableAddress[y] : +# 139| r139_4(double) = Load : &:r139_3, m133_7 +# 139| r139_5(bool) = CompareGT : r139_2, r139_4 +# 139| r139_6(glval) = VariableAddress[b] : +# 139| m139_7(bool) = Store : &:r139_6, r139_5 +# 140| r140_1(glval) = VariableAddress[x] : +# 140| r140_2(double) = Load : &:r140_1, m133_5 +# 140| r140_3(glval) = VariableAddress[y] : +# 140| r140_4(double) = Load : &:r140_3, m133_7 +# 140| r140_5(bool) = CompareLE : r140_2, r140_4 +# 140| r140_6(glval) = VariableAddress[b] : +# 140| m140_7(bool) = Store : &:r140_6, r140_5 +# 141| r141_1(glval) = VariableAddress[x] : +# 141| r141_2(double) = Load : &:r141_1, m133_5 +# 141| r141_3(glval) = VariableAddress[y] : +# 141| r141_4(double) = Load : &:r141_3, m133_7 +# 141| r141_5(bool) = CompareGE : r141_2, r141_4 +# 141| r141_6(glval) = VariableAddress[b] : +# 141| m141_7(bool) = Store : &:r141_6, r141_5 +# 142| v142_1(void) = NoOp : +# 133| v133_8(void) = ReturnVoid : +# 133| v133_9(void) = UnmodeledUse : mu* +# 133| v133_10(void) = AliasedUse : ~mu133_3 +# 133| v133_11(void) = ExitFunction : + +# 144| void FloatCrement(float) +# 144| Block 0 +# 144| v144_1(void) = EnterFunction : +# 144| mu144_2(unknown) = AliasedDefinition : +# 144| mu144_3(unknown) = UnmodeledDefinition : +# 144| r144_4(glval) = VariableAddress[x] : +# 144| m144_5(float) = InitializeParameter[x] : &:r144_4 +# 145| r145_1(glval) = VariableAddress[y] : +# 145| m145_2(float) = Uninitialized[y] : &:r145_1 +# 147| r147_1(glval) = VariableAddress[x] : +# 147| r147_2(float) = Load : &:r147_1, m144_5 +# 147| r147_3(float) = Constant[1.0] : +# 147| r147_4(float) = Add : r147_2, r147_3 +# 147| m147_5(float) = Store : &:r147_1, r147_4 +# 147| r147_6(glval) = VariableAddress[y] : +# 147| m147_7(float) = Store : &:r147_6, r147_4 +# 148| r148_1(glval) = VariableAddress[x] : +# 148| r148_2(float) = Load : &:r148_1, m147_5 +# 148| r148_3(float) = Constant[1.0] : +# 148| r148_4(float) = Sub : r148_2, r148_3 +# 148| m148_5(float) = Store : &:r148_1, r148_4 +# 148| r148_6(glval) = VariableAddress[y] : +# 148| m148_7(float) = Store : &:r148_6, r148_4 +# 149| r149_1(glval) = VariableAddress[x] : +# 149| r149_2(float) = Load : &:r149_1, m148_5 +# 149| r149_3(float) = Constant[1.0] : +# 149| r149_4(float) = Add : r149_2, r149_3 +# 149| m149_5(float) = Store : &:r149_1, r149_4 +# 149| r149_6(glval) = VariableAddress[y] : +# 149| m149_7(float) = Store : &:r149_6, r149_2 +# 150| r150_1(glval) = VariableAddress[x] : +# 150| r150_2(float) = Load : &:r150_1, m149_5 +# 150| r150_3(float) = Constant[1.0] : +# 150| r150_4(float) = Sub : r150_2, r150_3 +# 150| m150_5(float) = Store : &:r150_1, r150_4 +# 150| r150_6(glval) = VariableAddress[y] : +# 150| m150_7(float) = Store : &:r150_6, r150_2 +# 151| v151_1(void) = NoOp : +# 144| v144_6(void) = ReturnVoid : +# 144| v144_7(void) = UnmodeledUse : mu* +# 144| v144_8(void) = AliasedUse : ~mu144_3 +# 144| v144_9(void) = ExitFunction : + +# 153| void PointerOps(int*, int) +# 153| Block 0 +# 153| v153_1(void) = EnterFunction : +# 153| mu153_2(unknown) = AliasedDefinition : +# 153| mu153_3(unknown) = UnmodeledDefinition : +# 153| r153_4(glval) = VariableAddress[p] : +# 153| m153_5(int *) = InitializeParameter[p] : &:r153_4 +# 153| r153_6(int *) = Load : &:r153_4, m153_5 +# 153| mu153_7(unknown) = InitializeIndirection[p] : &:r153_6 +# 153| r153_8(glval) = VariableAddress[i] : +# 153| m153_9(int) = InitializeParameter[i] : &:r153_8 +# 154| r154_1(glval) = VariableAddress[q] : +# 154| m154_2(int *) = Uninitialized[q] : &:r154_1 +# 155| r155_1(glval) = VariableAddress[b] : +# 155| m155_2(bool) = Uninitialized[b] : &:r155_1 +# 157| r157_1(glval) = VariableAddress[p] : +# 157| r157_2(int *) = Load : &:r157_1, m153_5 +# 157| r157_3(glval) = VariableAddress[i] : +# 157| r157_4(int) = Load : &:r157_3, m153_9 +# 157| r157_5(int *) = PointerAdd[4] : r157_2, r157_4 +# 157| r157_6(glval) = VariableAddress[q] : +# 157| m157_7(int *) = Store : &:r157_6, r157_5 +# 158| r158_1(glval) = VariableAddress[i] : +# 158| r158_2(int) = Load : &:r158_1, m153_9 +# 158| r158_3(glval) = VariableAddress[p] : +# 158| r158_4(int *) = Load : &:r158_3, m153_5 +# 158| r158_5(int *) = PointerAdd[4] : r158_4, r158_2 +# 158| r158_6(glval) = VariableAddress[q] : +# 158| m158_7(int *) = Store : &:r158_6, r158_5 +# 159| r159_1(glval) = VariableAddress[p] : +# 159| r159_2(int *) = Load : &:r159_1, m153_5 +# 159| r159_3(glval) = VariableAddress[i] : +# 159| r159_4(int) = Load : &:r159_3, m153_9 +# 159| r159_5(int *) = PointerSub[4] : r159_2, r159_4 +# 159| r159_6(glval) = VariableAddress[q] : +# 159| m159_7(int *) = Store : &:r159_6, r159_5 +# 160| r160_1(glval) = VariableAddress[p] : +# 160| r160_2(int *) = Load : &:r160_1, m153_5 +# 160| r160_3(glval) = VariableAddress[q] : +# 160| r160_4(int *) = Load : &:r160_3, m159_7 +# 160| r160_5(long) = PointerDiff[4] : r160_2, r160_4 +# 160| r160_6(int) = Convert : r160_5 +# 160| r160_7(glval) = VariableAddress[i] : +# 160| m160_8(int) = Store : &:r160_7, r160_6 +# 162| r162_1(glval) = VariableAddress[p] : +# 162| r162_2(int *) = Load : &:r162_1, m153_5 +# 162| r162_3(glval) = VariableAddress[q] : +# 162| m162_4(int *) = Store : &:r162_3, r162_2 +# 164| r164_1(glval) = VariableAddress[i] : +# 164| r164_2(int) = Load : &:r164_1, m160_8 +# 164| r164_3(glval) = VariableAddress[q] : +# 164| r164_4(int *) = Load : &:r164_3, m162_4 +# 164| r164_5(int *) = PointerAdd[4] : r164_4, r164_2 +# 164| m164_6(int *) = Store : &:r164_3, r164_5 +# 165| r165_1(glval) = VariableAddress[i] : +# 165| r165_2(int) = Load : &:r165_1, m160_8 +# 165| r165_3(glval) = VariableAddress[q] : +# 165| r165_4(int *) = Load : &:r165_3, m164_6 +# 165| r165_5(int *) = PointerSub[4] : r165_4, r165_2 +# 165| m165_6(int *) = Store : &:r165_3, r165_5 +# 167| r167_1(glval) = VariableAddress[p] : +# 167| r167_2(int *) = Load : &:r167_1, m153_5 +# 167| r167_3(int *) = Constant[0] : +# 167| r167_4(bool) = CompareNE : r167_2, r167_3 +# 167| r167_5(glval) = VariableAddress[b] : +# 167| m167_6(bool) = Store : &:r167_5, r167_4 +# 168| r168_1(glval) = VariableAddress[p] : +# 168| r168_2(int *) = Load : &:r168_1, m153_5 +# 168| r168_3(int *) = Constant[0] : +# 168| r168_4(bool) = CompareNE : r168_2, r168_3 +# 168| r168_5(bool) = LogicalNot : r168_4 +# 168| r168_6(glval) = VariableAddress[b] : +# 168| m168_7(bool) = Store : &:r168_6, r168_5 +# 169| v169_1(void) = NoOp : +# 153| v153_10(void) = ReturnIndirection : &:r153_6, ~mu153_3 +# 153| v153_11(void) = ReturnVoid : +# 153| v153_12(void) = UnmodeledUse : mu* +# 153| v153_13(void) = AliasedUse : ~mu153_3 +# 153| v153_14(void) = ExitFunction : + +# 171| void ArrayAccess(int*, int) +# 171| Block 0 +# 171| v171_1(void) = EnterFunction : +# 171| mu171_2(unknown) = AliasedDefinition : +# 171| mu171_3(unknown) = UnmodeledDefinition : +# 171| r171_4(glval) = VariableAddress[p] : +# 171| m171_5(int *) = InitializeParameter[p] : &:r171_4 +# 171| r171_6(int *) = Load : &:r171_4, m171_5 +# 171| mu171_7(unknown) = InitializeIndirection[p] : &:r171_6 +# 171| r171_8(glval) = VariableAddress[i] : +# 171| m171_9(int) = InitializeParameter[i] : &:r171_8 +# 172| r172_1(glval) = VariableAddress[x] : +# 172| m172_2(int) = Uninitialized[x] : &:r172_1 +# 174| r174_1(glval) = VariableAddress[p] : +# 174| r174_2(int *) = Load : &:r174_1, m171_5 +# 174| r174_3(glval) = VariableAddress[i] : +# 174| r174_4(int) = Load : &:r174_3, m171_9 +# 174| r174_5(glval) = PointerAdd[4] : r174_2, r174_4 +# 174| r174_6(int) = Load : &:r174_5, ~mu171_3 +# 174| r174_7(glval) = VariableAddress[x] : +# 174| m174_8(int) = Store : &:r174_7, r174_6 +# 175| r175_1(glval) = VariableAddress[p] : +# 175| r175_2(int *) = Load : &:r175_1, m171_5 +# 175| r175_3(glval) = VariableAddress[i] : +# 175| r175_4(int) = Load : &:r175_3, m171_9 +# 175| r175_5(glval) = PointerAdd[4] : r175_2, r175_4 +# 175| r175_6(int) = Load : &:r175_5, ~mu171_3 +# 175| r175_7(glval) = VariableAddress[x] : +# 175| m175_8(int) = Store : &:r175_7, r175_6 +# 177| r177_1(glval) = VariableAddress[x] : +# 177| r177_2(int) = Load : &:r177_1, m175_8 +# 177| r177_3(glval) = VariableAddress[p] : +# 177| r177_4(int *) = Load : &:r177_3, m171_5 +# 177| r177_5(glval) = VariableAddress[i] : +# 177| r177_6(int) = Load : &:r177_5, m171_9 +# 177| r177_7(glval) = PointerAdd[4] : r177_4, r177_6 +# 177| mu177_8(int) = Store : &:r177_7, r177_2 +# 178| r178_1(glval) = VariableAddress[x] : +# 178| r178_2(int) = Load : &:r178_1, m175_8 +# 178| r178_3(glval) = VariableAddress[p] : +# 178| r178_4(int *) = Load : &:r178_3, m171_5 +# 178| r178_5(glval) = VariableAddress[i] : +# 178| r178_6(int) = Load : &:r178_5, m171_9 +# 178| r178_7(glval) = PointerAdd[4] : r178_4, r178_6 +# 178| mu178_8(int) = Store : &:r178_7, r178_2 +# 180| r180_1(glval) = VariableAddress[a] : +# 180| mu180_2(int[10]) = Uninitialized[a] : &:r180_1 +# 181| r181_1(glval) = VariableAddress[a] : +# 181| r181_2(int *) = Convert : r181_1 +# 181| r181_3(glval) = VariableAddress[i] : +# 181| r181_4(int) = Load : &:r181_3, m171_9 +# 181| r181_5(glval) = PointerAdd[4] : r181_2, r181_4 +# 181| r181_6(int) = Load : &:r181_5, ~mu171_3 +# 181| r181_7(glval) = VariableAddress[x] : +# 181| m181_8(int) = Store : &:r181_7, r181_6 +# 182| r182_1(glval) = VariableAddress[a] : +# 182| r182_2(int *) = Convert : r182_1 +# 182| r182_3(glval) = VariableAddress[i] : +# 182| r182_4(int) = Load : &:r182_3, m171_9 +# 182| r182_5(glval) = PointerAdd[4] : r182_2, r182_4 +# 182| r182_6(int) = Load : &:r182_5, ~mu171_3 +# 182| r182_7(glval) = VariableAddress[x] : +# 182| m182_8(int) = Store : &:r182_7, r182_6 +# 183| r183_1(glval) = VariableAddress[x] : +# 183| r183_2(int) = Load : &:r183_1, m182_8 +# 183| r183_3(glval) = VariableAddress[a] : +# 183| r183_4(int *) = Convert : r183_3 +# 183| r183_5(glval) = VariableAddress[i] : +# 183| r183_6(int) = Load : &:r183_5, m171_9 +# 183| r183_7(glval) = PointerAdd[4] : r183_4, r183_6 +# 183| mu183_8(int) = Store : &:r183_7, r183_2 +# 184| r184_1(glval) = VariableAddress[x] : +# 184| r184_2(int) = Load : &:r184_1, m182_8 +# 184| r184_3(glval) = VariableAddress[a] : +# 184| r184_4(int *) = Convert : r184_3 +# 184| r184_5(glval) = VariableAddress[i] : +# 184| r184_6(int) = Load : &:r184_5, m171_9 +# 184| r184_7(glval) = PointerAdd[4] : r184_4, r184_6 +# 184| mu184_8(int) = Store : &:r184_7, r184_2 +# 185| v185_1(void) = NoOp : +# 171| v171_10(void) = ReturnIndirection : &:r171_6, ~mu171_3 +# 171| v171_11(void) = ReturnVoid : +# 171| v171_12(void) = UnmodeledUse : mu* +# 171| v171_13(void) = AliasedUse : ~mu171_3 +# 171| v171_14(void) = ExitFunction : + +# 187| void StringLiteral(int) +# 187| Block 0 +# 187| v187_1(void) = EnterFunction : +# 187| mu187_2(unknown) = AliasedDefinition : +# 187| mu187_3(unknown) = UnmodeledDefinition : +# 187| r187_4(glval) = VariableAddress[i] : +# 187| m187_5(int) = InitializeParameter[i] : &:r187_4 +# 188| r188_1(glval) = VariableAddress[c] : +# 188| r188_2(glval) = StringConstant["Foo"] : +# 188| r188_3(char *) = Convert : r188_2 +# 188| r188_4(glval) = VariableAddress[i] : +# 188| r188_5(int) = Load : &:r188_4, m187_5 +# 188| r188_6(glval) = PointerAdd[1] : r188_3, r188_5 +# 188| r188_7(char) = Load : &:r188_6, ~mu187_3 +# 188| m188_8(char) = Store : &:r188_1, r188_7 +# 189| r189_1(glval) = VariableAddress[pwc] : +# 189| r189_2(glval) = StringConstant[L"Bar"] : +# 189| r189_3(wchar_t *) = Convert : r189_2 +# 189| r189_4(wchar_t *) = Convert : r189_3 +# 189| m189_5(wchar_t *) = Store : &:r189_1, r189_4 +# 190| r190_1(glval) = VariableAddress[wc] : +# 190| r190_2(glval) = VariableAddress[pwc] : +# 190| r190_3(wchar_t *) = Load : &:r190_2, m189_5 +# 190| r190_4(glval) = VariableAddress[i] : +# 190| r190_5(int) = Load : &:r190_4, m187_5 +# 190| r190_6(glval) = PointerAdd[4] : r190_3, r190_5 +# 190| r190_7(wchar_t) = Load : &:r190_6, ~mu187_3 +# 190| m190_8(wchar_t) = Store : &:r190_1, r190_7 +# 191| v191_1(void) = NoOp : +# 187| v187_6(void) = ReturnVoid : +# 187| v187_7(void) = UnmodeledUse : mu* +# 187| v187_8(void) = AliasedUse : ~mu187_3 +# 187| v187_9(void) = ExitFunction : + +# 193| void PointerCompare(int*, int*) +# 193| Block 0 +# 193| v193_1(void) = EnterFunction : +# 193| mu193_2(unknown) = AliasedDefinition : +# 193| mu193_3(unknown) = UnmodeledDefinition : +# 193| r193_4(glval) = VariableAddress[p] : +# 193| m193_5(int *) = InitializeParameter[p] : &:r193_4 +# 193| r193_6(int *) = Load : &:r193_4, m193_5 +# 193| mu193_7(unknown) = InitializeIndirection[p] : &:r193_6 +# 193| r193_8(glval) = VariableAddress[q] : +# 193| m193_9(int *) = InitializeParameter[q] : &:r193_8 +# 193| r193_10(int *) = Load : &:r193_8, m193_9 +# 193| mu193_11(unknown) = InitializeIndirection[q] : &:r193_10 +# 194| r194_1(glval) = VariableAddress[b] : +# 194| m194_2(bool) = Uninitialized[b] : &:r194_1 +# 196| r196_1(glval) = VariableAddress[p] : +# 196| r196_2(int *) = Load : &:r196_1, m193_5 +# 196| r196_3(glval) = VariableAddress[q] : +# 196| r196_4(int *) = Load : &:r196_3, m193_9 +# 196| r196_5(bool) = CompareEQ : r196_2, r196_4 +# 196| r196_6(glval) = VariableAddress[b] : +# 196| m196_7(bool) = Store : &:r196_6, r196_5 +# 197| r197_1(glval) = VariableAddress[p] : +# 197| r197_2(int *) = Load : &:r197_1, m193_5 +# 197| r197_3(glval) = VariableAddress[q] : +# 197| r197_4(int *) = Load : &:r197_3, m193_9 +# 197| r197_5(bool) = CompareNE : r197_2, r197_4 +# 197| r197_6(glval) = VariableAddress[b] : +# 197| m197_7(bool) = Store : &:r197_6, r197_5 +# 198| r198_1(glval) = VariableAddress[p] : +# 198| r198_2(int *) = Load : &:r198_1, m193_5 +# 198| r198_3(glval) = VariableAddress[q] : +# 198| r198_4(int *) = Load : &:r198_3, m193_9 +# 198| r198_5(bool) = CompareLT : r198_2, r198_4 +# 198| r198_6(glval) = VariableAddress[b] : +# 198| m198_7(bool) = Store : &:r198_6, r198_5 +# 199| r199_1(glval) = VariableAddress[p] : +# 199| r199_2(int *) = Load : &:r199_1, m193_5 +# 199| r199_3(glval) = VariableAddress[q] : +# 199| r199_4(int *) = Load : &:r199_3, m193_9 +# 199| r199_5(bool) = CompareGT : r199_2, r199_4 +# 199| r199_6(glval) = VariableAddress[b] : +# 199| m199_7(bool) = Store : &:r199_6, r199_5 +# 200| r200_1(glval) = VariableAddress[p] : +# 200| r200_2(int *) = Load : &:r200_1, m193_5 +# 200| r200_3(glval) = VariableAddress[q] : +# 200| r200_4(int *) = Load : &:r200_3, m193_9 +# 200| r200_5(bool) = CompareLE : r200_2, r200_4 +# 200| r200_6(glval) = VariableAddress[b] : +# 200| m200_7(bool) = Store : &:r200_6, r200_5 +# 201| r201_1(glval) = VariableAddress[p] : +# 201| r201_2(int *) = Load : &:r201_1, m193_5 +# 201| r201_3(glval) = VariableAddress[q] : +# 201| r201_4(int *) = Load : &:r201_3, m193_9 +# 201| r201_5(bool) = CompareGE : r201_2, r201_4 +# 201| r201_6(glval) = VariableAddress[b] : +# 201| m201_7(bool) = Store : &:r201_6, r201_5 +# 202| v202_1(void) = NoOp : +# 193| v193_12(void) = ReturnIndirection : &:r193_6, ~mu193_3 +# 193| v193_13(void) = ReturnIndirection : &:r193_10, ~mu193_3 +# 193| v193_14(void) = ReturnVoid : +# 193| v193_15(void) = UnmodeledUse : mu* +# 193| v193_16(void) = AliasedUse : ~mu193_3 +# 193| v193_17(void) = ExitFunction : + +# 204| void PointerCrement(int*) +# 204| Block 0 +# 204| v204_1(void) = EnterFunction : +# 204| mu204_2(unknown) = AliasedDefinition : +# 204| mu204_3(unknown) = UnmodeledDefinition : +# 204| r204_4(glval) = VariableAddress[p] : +# 204| m204_5(int *) = InitializeParameter[p] : &:r204_4 +# 204| r204_6(int *) = Load : &:r204_4, m204_5 +# 204| mu204_7(unknown) = InitializeIndirection[p] : &:r204_6 +# 205| r205_1(glval) = VariableAddress[q] : +# 205| m205_2(int *) = Uninitialized[q] : &:r205_1 +# 207| r207_1(glval) = VariableAddress[p] : +# 207| r207_2(int *) = Load : &:r207_1, m204_5 +# 207| r207_3(int) = Constant[1] : +# 207| r207_4(int *) = PointerAdd[4] : r207_2, r207_3 +# 207| m207_5(int *) = Store : &:r207_1, r207_4 +# 207| r207_6(glval) = VariableAddress[q] : +# 207| m207_7(int *) = Store : &:r207_6, r207_4 +# 208| r208_1(glval) = VariableAddress[p] : +# 208| r208_2(int *) = Load : &:r208_1, m207_5 +# 208| r208_3(int) = Constant[1] : +# 208| r208_4(int *) = PointerSub[4] : r208_2, r208_3 +# 208| m208_5(int *) = Store : &:r208_1, r208_4 +# 208| r208_6(glval) = VariableAddress[q] : +# 208| m208_7(int *) = Store : &:r208_6, r208_4 +# 209| r209_1(glval) = VariableAddress[p] : +# 209| r209_2(int *) = Load : &:r209_1, m208_5 +# 209| r209_3(int) = Constant[1] : +# 209| r209_4(int *) = PointerAdd[4] : r209_2, r209_3 +# 209| m209_5(int *) = Store : &:r209_1, r209_4 +# 209| r209_6(glval) = VariableAddress[q] : +# 209| m209_7(int *) = Store : &:r209_6, r209_2 +# 210| r210_1(glval) = VariableAddress[p] : +# 210| r210_2(int *) = Load : &:r210_1, m209_5 +# 210| r210_3(int) = Constant[1] : +# 210| r210_4(int *) = PointerSub[4] : r210_2, r210_3 +# 210| m210_5(int *) = Store : &:r210_1, r210_4 +# 210| r210_6(glval) = VariableAddress[q] : +# 210| m210_7(int *) = Store : &:r210_6, r210_2 +# 211| v211_1(void) = NoOp : +# 204| v204_8(void) = ReturnIndirection : &:r204_6, ~mu204_3 +# 204| v204_9(void) = ReturnVoid : +# 204| v204_10(void) = UnmodeledUse : mu* +# 204| v204_11(void) = AliasedUse : ~mu204_3 +# 204| v204_12(void) = ExitFunction : + +# 213| void CompoundAssignment() +# 213| Block 0 +# 213| v213_1(void) = EnterFunction : +# 213| mu213_2(unknown) = AliasedDefinition : +# 213| mu213_3(unknown) = UnmodeledDefinition : +# 215| r215_1(glval) = VariableAddress[x] : +# 215| r215_2(int) = Constant[5] : +# 215| m215_3(int) = Store : &:r215_1, r215_2 +# 216| r216_1(int) = Constant[7] : +# 216| r216_2(glval) = VariableAddress[x] : +# 216| r216_3(int) = Load : &:r216_2, m215_3 +# 216| r216_4(int) = Add : r216_3, r216_1 +# 216| m216_5(int) = Store : &:r216_2, r216_4 +# 219| r219_1(glval) = VariableAddress[y] : +# 219| r219_2(short) = Constant[5] : +# 219| m219_3(short) = Store : &:r219_1, r219_2 +# 220| r220_1(glval) = VariableAddress[x] : +# 220| r220_2(int) = Load : &:r220_1, m216_5 +# 220| r220_3(glval) = VariableAddress[y] : +# 220| r220_4(short) = Load : &:r220_3, m219_3 +# 220| r220_5(int) = Convert : r220_4 +# 220| r220_6(int) = Add : r220_5, r220_2 +# 220| r220_7(short) = Convert : r220_6 +# 220| m220_8(short) = Store : &:r220_3, r220_7 +# 223| r223_1(int) = Constant[1] : +# 223| r223_2(glval) = VariableAddress[y] : +# 223| r223_3(short) = Load : &:r223_2, m220_8 +# 223| r223_4(short) = ShiftLeft : r223_3, r223_1 +# 223| m223_5(short) = Store : &:r223_2, r223_4 +# 226| r226_1(glval) = VariableAddress[z] : +# 226| r226_2(long) = Constant[7] : +# 226| m226_3(long) = Store : &:r226_1, r226_2 +# 227| r227_1(float) = Constant[2.0] : +# 227| r227_2(glval) = VariableAddress[z] : +# 227| r227_3(long) = Load : &:r227_2, m226_3 +# 227| r227_4(float) = Convert : r227_3 +# 227| r227_5(float) = Add : r227_4, r227_1 +# 227| r227_6(long) = Convert : r227_5 +# 227| m227_7(long) = Store : &:r227_2, r227_6 +# 228| v228_1(void) = NoOp : +# 213| v213_4(void) = ReturnVoid : +# 213| v213_5(void) = UnmodeledUse : mu* +# 213| v213_6(void) = AliasedUse : ~mu213_3 +# 213| v213_7(void) = ExitFunction : + +# 230| void UninitializedVariables() +# 230| Block 0 +# 230| v230_1(void) = EnterFunction : +# 230| mu230_2(unknown) = AliasedDefinition : +# 230| mu230_3(unknown) = UnmodeledDefinition : +# 231| r231_1(glval) = VariableAddress[x] : +# 231| m231_2(int) = Uninitialized[x] : &:r231_1 +# 232| r232_1(glval) = VariableAddress[y] : +# 232| r232_2(glval) = VariableAddress[x] : +# 232| r232_3(int) = Load : &:r232_2, m231_2 +# 232| m232_4(int) = Store : &:r232_1, r232_3 +# 233| v233_1(void) = NoOp : +# 230| v230_4(void) = ReturnVoid : +# 230| v230_5(void) = UnmodeledUse : mu* +# 230| v230_6(void) = AliasedUse : ~mu230_3 +# 230| v230_7(void) = ExitFunction : + +# 235| int Parameters(int, int) +# 235| Block 0 +# 235| v235_1(void) = EnterFunction : +# 235| mu235_2(unknown) = AliasedDefinition : +# 235| mu235_3(unknown) = UnmodeledDefinition : +# 235| r235_4(glval) = VariableAddress[x] : +# 235| m235_5(int) = InitializeParameter[x] : &:r235_4 +# 235| r235_6(glval) = VariableAddress[y] : +# 235| m235_7(int) = InitializeParameter[y] : &:r235_6 +# 236| r236_1(glval) = VariableAddress[#return] : +# 236| r236_2(glval) = VariableAddress[x] : +# 236| r236_3(int) = Load : &:r236_2, m235_5 +# 236| r236_4(glval) = VariableAddress[y] : +# 236| r236_5(int) = Load : &:r236_4, m235_7 +# 236| r236_6(int) = Rem : r236_3, r236_5 +# 236| m236_7(int) = Store : &:r236_1, r236_6 +# 235| r235_8(glval) = VariableAddress[#return] : +# 235| v235_9(void) = ReturnValue : &:r235_8, m236_7 +# 235| v235_10(void) = UnmodeledUse : mu* +# 235| v235_11(void) = AliasedUse : ~mu235_3 +# 235| v235_12(void) = ExitFunction : + +# 239| void IfStatements(bool, int, int) +# 239| Block 0 +# 239| v239_1(void) = EnterFunction : +# 239| mu239_2(unknown) = AliasedDefinition : +# 239| mu239_3(unknown) = UnmodeledDefinition : +# 239| r239_4(glval) = VariableAddress[b] : +# 239| m239_5(bool) = InitializeParameter[b] : &:r239_4 +# 239| r239_6(glval) = VariableAddress[x] : +# 239| m239_7(int) = InitializeParameter[x] : &:r239_6 +# 239| r239_8(glval) = VariableAddress[y] : +# 239| m239_9(int) = InitializeParameter[y] : &:r239_8 +# 240| r240_1(glval) = VariableAddress[b] : +# 240| r240_2(bool) = Load : &:r240_1, m239_5 +# 240| v240_3(void) = ConditionalBranch : r240_2 +#-----| False -> Block 1 +#-----| True -> Block 7 + +# 243| Block 1 +# 243| r243_1(glval) = VariableAddress[b] : +# 243| r243_2(bool) = Load : &:r243_1, m239_5 +# 243| v243_3(void) = ConditionalBranch : r243_2 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 244| Block 2 +# 244| r244_1(glval) = VariableAddress[y] : +# 244| r244_2(int) = Load : &:r244_1, m239_9 +# 244| r244_3(glval) = VariableAddress[x] : +# 244| m244_4(int) = Store : &:r244_3, r244_2 +#-----| Goto -> Block 3 + +# 247| Block 3 +# 247| m247_1(int) = Phi : from 1:m239_7, from 2:m244_4 +# 247| r247_2(glval) = VariableAddress[x] : +# 247| r247_3(int) = Load : &:r247_2, m247_1 +# 247| r247_4(int) = Constant[7] : +# 247| r247_5(bool) = CompareLT : r247_3, r247_4 +# 247| v247_6(void) = ConditionalBranch : r247_5 +#-----| False -> Block 5 +#-----| True -> Block 4 + +# 248| Block 4 +# 248| r248_1(int) = Constant[2] : +# 248| r248_2(glval) = VariableAddress[x] : +# 248| m248_3(int) = Store : &:r248_2, r248_1 +#-----| Goto -> Block 6 + +# 250| Block 5 +# 250| r250_1(int) = Constant[7] : +# 250| r250_2(glval) = VariableAddress[x] : +# 250| m250_3(int) = Store : &:r250_2, r250_1 +#-----| Goto -> Block 6 + +# 251| Block 6 +# 251| v251_1(void) = NoOp : +# 239| v239_10(void) = ReturnVoid : +# 239| v239_11(void) = UnmodeledUse : mu* +# 239| v239_12(void) = AliasedUse : ~mu239_3 +# 239| v239_13(void) = ExitFunction : + +# 240| Block 7 +# 240| v240_4(void) = NoOp : +#-----| Goto -> Block 1 + +# 253| void WhileStatements(int) +# 253| Block 0 +# 253| v253_1(void) = EnterFunction : +# 253| mu253_2(unknown) = AliasedDefinition : +# 253| mu253_3(unknown) = UnmodeledDefinition : +# 253| r253_4(glval) = VariableAddress[n] : +# 253| m253_5(int) = InitializeParameter[n] : &:r253_4 +#-----| Goto -> Block 3 + +# 255| Block 1 +# 255| r255_1(int) = Constant[1] : +# 255| r255_2(glval) = VariableAddress[n] : +# 255| r255_3(int) = Load : &:r255_2, m254_1 +# 255| r255_4(int) = Sub : r255_3, r255_1 +# 255| m255_5(int) = Store : &:r255_2, r255_4 +#-----| Goto (back edge) -> Block 3 + +# 257| Block 2 +# 257| v257_1(void) = NoOp : +# 253| v253_6(void) = ReturnVoid : +# 253| v253_7(void) = UnmodeledUse : mu* +# 253| v253_8(void) = AliasedUse : ~mu253_3 +# 253| v253_9(void) = ExitFunction : + +# 254| Block 3 +# 254| m254_1(int) = Phi : from 0:m253_5, from 1:m255_5 +# 254| r254_2(glval) = VariableAddress[n] : +# 254| r254_3(int) = Load : &:r254_2, m254_1 +# 254| r254_4(int) = Constant[0] : +# 254| r254_5(bool) = CompareGT : r254_3, r254_4 +# 254| v254_6(void) = ConditionalBranch : r254_5 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 259| void DoStatements(int) +# 259| Block 0 +# 259| v259_1(void) = EnterFunction : +# 259| mu259_2(unknown) = AliasedDefinition : +# 259| mu259_3(unknown) = UnmodeledDefinition : +# 259| r259_4(glval) = VariableAddress[n] : +# 259| m259_5(int) = InitializeParameter[n] : &:r259_4 +#-----| Goto -> Block 1 + +# 261| Block 1 +# 261| m261_1(int) = Phi : from 0:m259_5, from 1:m261_6 +# 261| r261_2(int) = Constant[1] : +# 261| r261_3(glval) = VariableAddress[n] : +# 261| r261_4(int) = Load : &:r261_3, m261_1 +# 261| r261_5(int) = Sub : r261_4, r261_2 +# 261| m261_6(int) = Store : &:r261_3, r261_5 +# 262| r262_1(glval) = VariableAddress[n] : +# 262| r262_2(int) = Load : &:r262_1, m261_6 +# 262| r262_3(int) = Constant[0] : +# 262| r262_4(bool) = CompareGT : r262_2, r262_3 +# 262| v262_5(void) = ConditionalBranch : r262_4 +#-----| False -> Block 2 +#-----| True (back edge) -> Block 1 + +# 263| Block 2 +# 263| v263_1(void) = NoOp : +# 259| v259_6(void) = ReturnVoid : +# 259| v259_7(void) = UnmodeledUse : mu* +# 259| v259_8(void) = AliasedUse : ~mu259_3 +# 259| v259_9(void) = ExitFunction : + +# 265| void For_Empty() +# 265| Block 0 +# 265| v265_1(void) = EnterFunction : +# 265| mu265_2(unknown) = AliasedDefinition : +# 265| mu265_3(unknown) = UnmodeledDefinition : +# 266| r266_1(glval) = VariableAddress[j] : +# 266| m266_2(int) = Uninitialized[j] : &:r266_1 +#-----| Goto -> Block 1 + +# 268| Block 1 +# 268| v268_1(void) = NoOp : +#-----| Goto (back edge) -> Block 1 + +# 272| void For_Init() +# 272| Block 0 +# 272| v272_1(void) = EnterFunction : +# 272| mu272_2(unknown) = AliasedDefinition : +# 272| mu272_3(unknown) = UnmodeledDefinition : +# 273| r273_1(glval) = VariableAddress[i] : +# 273| r273_2(int) = Constant[0] : +# 273| m273_3(int) = Store : &:r273_1, r273_2 +#-----| Goto -> Block 1 + +# 274| Block 1 +# 274| v274_1(void) = NoOp : +#-----| Goto (back edge) -> Block 1 + +# 278| void For_Condition() +# 278| Block 0 +# 278| v278_1(void) = EnterFunction : +# 278| mu278_2(unknown) = AliasedDefinition : +# 278| mu278_3(unknown) = UnmodeledDefinition : +# 279| r279_1(glval) = VariableAddress[i] : +# 279| r279_2(int) = Constant[0] : +# 279| m279_3(int) = Store : &:r279_1, r279_2 +#-----| Goto -> Block 1 + +# 280| Block 1 +# 280| r280_1(glval) = VariableAddress[i] : +# 280| r280_2(int) = Load : &:r280_1, m279_3 +# 280| r280_3(int) = Constant[10] : +# 280| r280_4(bool) = CompareLT : r280_2, r280_3 +# 280| v280_5(void) = ConditionalBranch : r280_4 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 281| Block 2 +# 281| v281_1(void) = NoOp : +#-----| Goto (back edge) -> Block 1 + +# 283| Block 3 +# 283| v283_1(void) = NoOp : +# 278| v278_4(void) = ReturnVoid : +# 278| v278_5(void) = UnmodeledUse : mu* +# 278| v278_6(void) = AliasedUse : ~mu278_3 +# 278| v278_7(void) = ExitFunction : + +# 285| void For_Update() +# 285| Block 0 +# 285| v285_1(void) = EnterFunction : +# 285| mu285_2(unknown) = AliasedDefinition : +# 285| mu285_3(unknown) = UnmodeledDefinition : +# 286| r286_1(glval) = VariableAddress[i] : +# 286| r286_2(int) = Constant[0] : +# 286| m286_3(int) = Store : &:r286_1, r286_2 +#-----| Goto -> Block 1 + +# 288| Block 1 +# 288| m288_1(int) = Phi : from 0:m286_3, from 1:m287_5 +# 288| v288_2(void) = NoOp : +# 287| r287_1(int) = Constant[1] : +# 287| r287_2(glval) = VariableAddress[i] : +# 287| r287_3(int) = Load : &:r287_2, m288_1 +# 287| r287_4(int) = Add : r287_3, r287_1 +# 287| m287_5(int) = Store : &:r287_2, r287_4 +#-----| Goto (back edge) -> Block 1 + +# 292| void For_InitCondition() +# 292| Block 0 +# 292| v292_1(void) = EnterFunction : +# 292| mu292_2(unknown) = AliasedDefinition : +# 292| mu292_3(unknown) = UnmodeledDefinition : +# 293| r293_1(glval) = VariableAddress[i] : +# 293| r293_2(int) = Constant[0] : +# 293| m293_3(int) = Store : &:r293_1, r293_2 +#-----| Goto -> Block 1 + +# 293| Block 1 +# 293| r293_4(glval) = VariableAddress[i] : +# 293| r293_5(int) = Load : &:r293_4, m293_3 +# 293| r293_6(int) = Constant[10] : +# 293| r293_7(bool) = CompareLT : r293_5, r293_6 +# 293| v293_8(void) = ConditionalBranch : r293_7 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 294| Block 2 +# 294| v294_1(void) = NoOp : +#-----| Goto (back edge) -> Block 1 + +# 296| Block 3 +# 296| v296_1(void) = NoOp : +# 292| v292_4(void) = ReturnVoid : +# 292| v292_5(void) = UnmodeledUse : mu* +# 292| v292_6(void) = AliasedUse : ~mu292_3 +# 292| v292_7(void) = ExitFunction : + +# 298| void For_InitUpdate() +# 298| Block 0 +# 298| v298_1(void) = EnterFunction : +# 298| mu298_2(unknown) = AliasedDefinition : +# 298| mu298_3(unknown) = UnmodeledDefinition : +# 299| r299_1(glval) = VariableAddress[i] : +# 299| r299_2(int) = Constant[0] : +# 299| m299_3(int) = Store : &:r299_1, r299_2 +#-----| Goto -> Block 1 + +# 300| Block 1 +# 300| m300_1(int) = Phi : from 0:m299_3, from 1:m299_8 +# 300| v300_2(void) = NoOp : +# 299| r299_4(int) = Constant[1] : +# 299| r299_5(glval) = VariableAddress[i] : +# 299| r299_6(int) = Load : &:r299_5, m300_1 +# 299| r299_7(int) = Add : r299_6, r299_4 +# 299| m299_8(int) = Store : &:r299_5, r299_7 +#-----| Goto (back edge) -> Block 1 + +# 304| void For_ConditionUpdate() +# 304| Block 0 +# 304| v304_1(void) = EnterFunction : +# 304| mu304_2(unknown) = AliasedDefinition : +# 304| mu304_3(unknown) = UnmodeledDefinition : +# 305| r305_1(glval) = VariableAddress[i] : +# 305| r305_2(int) = Constant[0] : +# 305| m305_3(int) = Store : &:r305_1, r305_2 +#-----| Goto -> Block 1 + +# 306| Block 1 +# 306| m306_1(int) = Phi : from 0:m305_3, from 2:m306_11 +# 306| r306_2(glval) = VariableAddress[i] : +# 306| r306_3(int) = Load : &:r306_2, m306_1 +# 306| r306_4(int) = Constant[10] : +# 306| r306_5(bool) = CompareLT : r306_3, r306_4 +# 306| v306_6(void) = ConditionalBranch : r306_5 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 307| Block 2 +# 307| v307_1(void) = NoOp : +# 306| r306_7(int) = Constant[1] : +# 306| r306_8(glval) = VariableAddress[i] : +# 306| r306_9(int) = Load : &:r306_8, m306_1 +# 306| r306_10(int) = Add : r306_9, r306_7 +# 306| m306_11(int) = Store : &:r306_8, r306_10 +#-----| Goto (back edge) -> Block 1 + +# 309| Block 3 +# 309| v309_1(void) = NoOp : +# 304| v304_4(void) = ReturnVoid : +# 304| v304_5(void) = UnmodeledUse : mu* +# 304| v304_6(void) = AliasedUse : ~mu304_3 +# 304| v304_7(void) = ExitFunction : + +# 311| void For_InitConditionUpdate() +# 311| Block 0 +# 311| v311_1(void) = EnterFunction : +# 311| mu311_2(unknown) = AliasedDefinition : +# 311| mu311_3(unknown) = UnmodeledDefinition : +# 312| r312_1(glval) = VariableAddress[i] : +# 312| r312_2(int) = Constant[0] : +# 312| m312_3(int) = Store : &:r312_1, r312_2 +#-----| Goto -> Block 1 + +# 312| Block 1 +# 312| m312_4(int) = Phi : from 0:m312_3, from 2:m312_14 +# 312| r312_5(glval) = VariableAddress[i] : +# 312| r312_6(int) = Load : &:r312_5, m312_4 +# 312| r312_7(int) = Constant[10] : +# 312| r312_8(bool) = CompareLT : r312_6, r312_7 +# 312| v312_9(void) = ConditionalBranch : r312_8 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 313| Block 2 +# 313| v313_1(void) = NoOp : +# 312| r312_10(int) = Constant[1] : +# 312| r312_11(glval) = VariableAddress[i] : +# 312| r312_12(int) = Load : &:r312_11, m312_4 +# 312| r312_13(int) = Add : r312_12, r312_10 +# 312| m312_14(int) = Store : &:r312_11, r312_13 +#-----| Goto (back edge) -> Block 1 + +# 315| Block 3 +# 315| v315_1(void) = NoOp : +# 311| v311_4(void) = ReturnVoid : +# 311| v311_5(void) = UnmodeledUse : mu* +# 311| v311_6(void) = AliasedUse : ~mu311_3 +# 311| v311_7(void) = ExitFunction : + +# 317| void For_Break() +# 317| Block 0 +# 317| v317_1(void) = EnterFunction : +# 317| mu317_2(unknown) = AliasedDefinition : +# 317| mu317_3(unknown) = UnmodeledDefinition : +# 318| r318_1(glval) = VariableAddress[i] : +# 318| r318_2(int) = Constant[0] : +# 318| m318_3(int) = Store : &:r318_1, r318_2 +#-----| Goto -> Block 1 + +# 318| Block 1 +# 318| m318_4(int) = Phi : from 0:m318_3, from 2:m318_14 +# 318| r318_5(glval) = VariableAddress[i] : +# 318| r318_6(int) = Load : &:r318_5, m318_4 +# 318| r318_7(int) = Constant[10] : +# 318| r318_8(bool) = CompareLT : r318_6, r318_7 +# 318| v318_9(void) = ConditionalBranch : r318_8 +#-----| False -> Block 5 +#-----| True -> Block 3 + +# 318| Block 2 +# 318| r318_10(int) = Constant[1] : +# 318| r318_11(glval) = VariableAddress[i] : +# 318| r318_12(int) = Load : &:r318_11, m318_4 +# 318| r318_13(int) = Add : r318_12, r318_10 +# 318| m318_14(int) = Store : &:r318_11, r318_13 +#-----| Goto (back edge) -> Block 1 + +# 319| Block 3 +# 319| r319_1(glval) = VariableAddress[i] : +# 319| r319_2(int) = Load : &:r319_1, m318_4 +# 319| r319_3(int) = Constant[5] : +# 319| r319_4(bool) = CompareEQ : r319_2, r319_3 +# 319| v319_5(void) = ConditionalBranch : r319_4 +#-----| False -> Block 2 +#-----| True -> Block 4 + +# 320| Block 4 +# 320| v320_1(void) = NoOp : +#-----| Goto -> Block 5 + +# 322| Block 5 +# 322| v322_1(void) = NoOp : +# 323| v323_1(void) = NoOp : +# 317| v317_4(void) = ReturnVoid : +# 317| v317_5(void) = UnmodeledUse : mu* +# 317| v317_6(void) = AliasedUse : ~mu317_3 +# 317| v317_7(void) = ExitFunction : + +# 325| void For_Continue_Update() +# 325| Block 0 +# 325| v325_1(void) = EnterFunction : +# 325| mu325_2(unknown) = AliasedDefinition : +# 325| mu325_3(unknown) = UnmodeledDefinition : +# 326| r326_1(glval) = VariableAddress[i] : +# 326| r326_2(int) = Constant[0] : +# 326| m326_3(int) = Store : &:r326_1, r326_2 +#-----| Goto -> Block 1 + +# 326| Block 1 +# 326| m326_4(int) = Phi : from 0:m326_3, from 4:m326_15 +# 326| r326_5(glval) = VariableAddress[i] : +# 326| r326_6(int) = Load : &:r326_5, m326_4 +# 326| r326_7(int) = Constant[10] : +# 326| r326_8(bool) = CompareLT : r326_6, r326_7 +# 326| v326_9(void) = ConditionalBranch : r326_8 +#-----| False -> Block 5 +#-----| True -> Block 2 + +# 327| Block 2 +# 327| r327_1(glval) = VariableAddress[i] : +# 327| r327_2(int) = Load : &:r327_1, m326_4 +# 327| r327_3(int) = Constant[5] : +# 327| r327_4(bool) = CompareEQ : r327_2, r327_3 +# 327| v327_5(void) = ConditionalBranch : r327_4 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 328| Block 3 +# 328| v328_1(void) = NoOp : +#-----| Goto -> Block 4 + +# 326| Block 4 +# 326| v326_10(void) = NoOp : +# 326| r326_11(int) = Constant[1] : +# 326| r326_12(glval) = VariableAddress[i] : +# 326| r326_13(int) = Load : &:r326_12, m326_4 +# 326| r326_14(int) = Add : r326_13, r326_11 +# 326| m326_15(int) = Store : &:r326_12, r326_14 +#-----| Goto (back edge) -> Block 1 + +# 331| Block 5 +# 331| v331_1(void) = NoOp : +# 325| v325_4(void) = ReturnVoid : +# 325| v325_5(void) = UnmodeledUse : mu* +# 325| v325_6(void) = AliasedUse : ~mu325_3 +# 325| v325_7(void) = ExitFunction : + +# 333| void For_Continue_NoUpdate() +# 333| Block 0 +# 333| v333_1(void) = EnterFunction : +# 333| mu333_2(unknown) = AliasedDefinition : +# 333| mu333_3(unknown) = UnmodeledDefinition : +# 334| r334_1(glval) = VariableAddress[i] : +# 334| r334_2(int) = Constant[0] : +# 334| m334_3(int) = Store : &:r334_1, r334_2 +#-----| Goto -> Block 1 + +# 334| Block 1 +# 334| r334_4(glval) = VariableAddress[i] : +# 334| r334_5(int) = Load : &:r334_4, m334_3 +# 334| r334_6(int) = Constant[10] : +# 334| r334_7(bool) = CompareLT : r334_5, r334_6 +# 334| v334_8(void) = ConditionalBranch : r334_7 +#-----| False -> Block 5 +#-----| True -> Block 2 + +# 335| Block 2 +# 335| r335_1(glval) = VariableAddress[i] : +# 335| r335_2(int) = Load : &:r335_1, m334_3 +# 335| r335_3(int) = Constant[5] : +# 335| r335_4(bool) = CompareEQ : r335_2, r335_3 +# 335| v335_5(void) = ConditionalBranch : r335_4 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 336| Block 3 +# 336| v336_1(void) = NoOp : +#-----| Goto -> Block 4 + +# 334| Block 4 +# 334| v334_9(void) = NoOp : +#-----| Goto (back edge) -> Block 1 + +# 339| Block 5 +# 339| v339_1(void) = NoOp : +# 333| v333_4(void) = ReturnVoid : +# 333| v333_5(void) = UnmodeledUse : mu* +# 333| v333_6(void) = AliasedUse : ~mu333_3 +# 333| v333_7(void) = ExitFunction : + +# 341| int Dereference(int*) +# 341| Block 0 +# 341| v341_1(void) = EnterFunction : +# 341| mu341_2(unknown) = AliasedDefinition : +# 341| mu341_3(unknown) = UnmodeledDefinition : +# 341| r341_4(glval) = VariableAddress[p] : +# 341| m341_5(int *) = InitializeParameter[p] : &:r341_4 +# 341| r341_6(int *) = Load : &:r341_4, m341_5 +# 341| mu341_7(unknown) = InitializeIndirection[p] : &:r341_6 +# 342| r342_1(int) = Constant[1] : +# 342| r342_2(glval) = VariableAddress[p] : +# 342| r342_3(int *) = Load : &:r342_2, m341_5 +# 342| r342_4(glval) = CopyValue : r342_3 +# 342| mu342_5(int) = Store : &:r342_4, r342_1 +# 343| r343_1(glval) = VariableAddress[#return] : +# 343| r343_2(glval) = VariableAddress[p] : +# 343| r343_3(int *) = Load : &:r343_2, m341_5 +# 343| r343_4(int) = Load : &:r343_3, ~mu341_3 +# 343| m343_5(int) = Store : &:r343_1, r343_4 +# 341| v341_8(void) = ReturnIndirection : &:r341_6, ~mu341_3 +# 341| r341_9(glval) = VariableAddress[#return] : +# 341| v341_10(void) = ReturnValue : &:r341_9, m343_5 +# 341| v341_11(void) = UnmodeledUse : mu* +# 341| v341_12(void) = AliasedUse : ~mu341_3 +# 341| v341_13(void) = ExitFunction : + +# 348| int* AddressOf() +# 348| Block 0 +# 348| v348_1(void) = EnterFunction : +# 348| mu348_2(unknown) = AliasedDefinition : +# 348| mu348_3(unknown) = UnmodeledDefinition : +# 349| r349_1(glval) = VariableAddress[#return] : +# 349| r349_2(glval) = VariableAddress[g] : +# 349| r349_3(int *) = CopyValue : r349_2 +# 349| m349_4(int *) = Store : &:r349_1, r349_3 +# 348| r348_4(glval) = VariableAddress[#return] : +# 348| v348_5(void) = ReturnValue : &:r348_4, m349_4 +# 348| v348_6(void) = UnmodeledUse : mu* +# 348| v348_7(void) = AliasedUse : ~mu348_3 +# 348| v348_8(void) = ExitFunction : + +# 352| void Break(int) +# 352| Block 0 +# 352| v352_1(void) = EnterFunction : +# 352| mu352_2(unknown) = AliasedDefinition : +# 352| mu352_3(unknown) = UnmodeledDefinition : +# 352| r352_4(glval) = VariableAddress[n] : +# 352| m352_5(int) = InitializeParameter[n] : &:r352_4 +#-----| Goto -> Block 5 + +# 354| Block 1 +# 354| r354_1(glval) = VariableAddress[n] : +# 354| r354_2(int) = Load : &:r354_1, m353_1 +# 354| r354_3(int) = Constant[1] : +# 354| r354_4(bool) = CompareEQ : r354_2, r354_3 +# 354| v354_5(void) = ConditionalBranch : r354_4 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 355| Block 2 +# 355| v355_1(void) = NoOp : +#-----| Goto -> Block 4 + +# 356| Block 3 +# 356| r356_1(int) = Constant[1] : +# 356| r356_2(glval) = VariableAddress[n] : +# 356| r356_3(int) = Load : &:r356_2, m353_1 +# 356| r356_4(int) = Sub : r356_3, r356_1 +# 356| m356_5(int) = Store : &:r356_2, r356_4 +#-----| Goto (back edge) -> Block 5 + +# 357| Block 4 +# 357| v357_1(void) = NoOp : +# 358| v358_1(void) = NoOp : +# 352| v352_6(void) = ReturnVoid : +# 352| v352_7(void) = UnmodeledUse : mu* +# 352| v352_8(void) = AliasedUse : ~mu352_3 +# 352| v352_9(void) = ExitFunction : + +# 353| Block 5 +# 353| m353_1(int) = Phi : from 0:m352_5, from 3:m356_5 +# 353| r353_2(glval) = VariableAddress[n] : +# 353| r353_3(int) = Load : &:r353_2, m353_1 +# 353| r353_4(int) = Constant[0] : +# 353| r353_5(bool) = CompareGT : r353_3, r353_4 +# 353| v353_6(void) = ConditionalBranch : r353_5 +#-----| False -> Block 4 +#-----| True -> Block 1 + +# 360| void Continue(int) +# 360| Block 0 +# 360| v360_1(void) = EnterFunction : +# 360| mu360_2(unknown) = AliasedDefinition : +# 360| mu360_3(unknown) = UnmodeledDefinition : +# 360| r360_4(glval) = VariableAddress[n] : +# 360| m360_5(int) = InitializeParameter[n] : &:r360_4 +#-----| Goto -> Block 1 + +# 362| Block 1 +# 362| m362_1(int) = Phi : from 0:m360_5, from 4:m361_1 +# 362| r362_2(glval) = VariableAddress[n] : +# 362| r362_3(int) = Load : &:r362_2, m362_1 +# 362| r362_4(int) = Constant[1] : +# 362| r362_5(bool) = CompareEQ : r362_3, r362_4 +# 362| v362_6(void) = ConditionalBranch : r362_5 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 363| Block 2 +# 363| v363_1(void) = NoOp : +#-----| Goto -> Block 4 + +# 365| Block 3 +# 365| r365_1(int) = Constant[1] : +# 365| r365_2(glval) = VariableAddress[n] : +# 365| r365_3(int) = Load : &:r365_2, m362_1 +# 365| r365_4(int) = Sub : r365_3, r365_1 +# 365| m365_5(int) = Store : &:r365_2, r365_4 +#-----| Goto -> Block 4 + +# 361| Block 4 +# 361| m361_1(int) = Phi : from 2:m362_1, from 3:m365_5 +# 361| v361_2(void) = NoOp : +# 366| r366_1(glval) = VariableAddress[n] : +# 366| r366_2(int) = Load : &:r366_1, m361_1 +# 366| r366_3(int) = Constant[0] : +# 366| r366_4(bool) = CompareGT : r366_2, r366_3 +# 366| v366_5(void) = ConditionalBranch : r366_4 +#-----| False -> Block 5 +#-----| True (back edge) -> Block 1 + +# 367| Block 5 +# 367| v367_1(void) = NoOp : +# 360| v360_6(void) = ReturnVoid : +# 360| v360_7(void) = UnmodeledUse : mu* +# 360| v360_8(void) = AliasedUse : ~mu360_3 +# 360| v360_9(void) = ExitFunction : + +# 372| void Call() +# 372| Block 0 +# 372| v372_1(void) = EnterFunction : +# 372| mu372_2(unknown) = AliasedDefinition : +# 372| mu372_3(unknown) = UnmodeledDefinition : +# 373| r373_1(glval) = FunctionAddress[VoidFunc] : +# 373| v373_2(void) = Call : func:r373_1 +# 373| mu373_3(unknown) = ^CallSideEffect : ~mu372_3 +# 374| v374_1(void) = NoOp : +# 372| v372_4(void) = ReturnVoid : +# 372| v372_5(void) = UnmodeledUse : mu* +# 372| v372_6(void) = AliasedUse : ~mu372_3 +# 372| v372_7(void) = ExitFunction : + +# 376| int CallAdd(int, int) +# 376| Block 0 +# 376| v376_1(void) = EnterFunction : +# 376| mu376_2(unknown) = AliasedDefinition : +# 376| mu376_3(unknown) = UnmodeledDefinition : +# 376| r376_4(glval) = VariableAddress[x] : +# 376| m376_5(int) = InitializeParameter[x] : &:r376_4 +# 376| r376_6(glval) = VariableAddress[y] : +# 376| m376_7(int) = InitializeParameter[y] : &:r376_6 +# 377| r377_1(glval) = VariableAddress[#return] : +# 377| r377_2(glval) = FunctionAddress[Add] : +# 377| r377_3(glval) = VariableAddress[x] : +# 377| r377_4(int) = Load : &:r377_3, m376_5 +# 377| r377_5(glval) = VariableAddress[y] : +# 377| r377_6(int) = Load : &:r377_5, m376_7 +# 377| r377_7(int) = Call : func:r377_2, 0:r377_4, 1:r377_6 +# 377| mu377_8(unknown) = ^CallSideEffect : ~mu376_3 +# 377| m377_9(int) = Store : &:r377_1, r377_7 +# 376| r376_8(glval) = VariableAddress[#return] : +# 376| v376_9(void) = ReturnValue : &:r376_8, m377_9 +# 376| v376_10(void) = UnmodeledUse : mu* +# 376| v376_11(void) = AliasedUse : ~mu376_3 +# 376| v376_12(void) = ExitFunction : + +# 380| int Comma(int, int) +# 380| Block 0 +# 380| v380_1(void) = EnterFunction : +# 380| mu380_2(unknown) = AliasedDefinition : +# 380| mu380_3(unknown) = UnmodeledDefinition : +# 380| r380_4(glval) = VariableAddress[x] : +# 380| m380_5(int) = InitializeParameter[x] : &:r380_4 +# 380| r380_6(glval) = VariableAddress[y] : +# 380| m380_7(int) = InitializeParameter[y] : &:r380_6 +# 381| r381_1(glval) = VariableAddress[#return] : +# 381| r381_2(glval) = FunctionAddress[VoidFunc] : +# 381| v381_3(void) = Call : func:r381_2 +# 381| mu381_4(unknown) = ^CallSideEffect : ~mu380_3 +# 381| r381_5(glval) = FunctionAddress[CallAdd] : +# 381| r381_6(glval) = VariableAddress[x] : +# 381| r381_7(int) = Load : &:r381_6, m380_5 +# 381| r381_8(glval) = VariableAddress[y] : +# 381| r381_9(int) = Load : &:r381_8, m380_7 +# 381| r381_10(int) = Call : func:r381_5, 0:r381_7, 1:r381_9 +# 381| mu381_11(unknown) = ^CallSideEffect : ~mu380_3 +# 381| r381_12(int) = CopyValue : r381_10 +# 381| m381_13(int) = Store : &:r381_1, r381_12 +# 380| r380_8(glval) = VariableAddress[#return] : +# 380| v380_9(void) = ReturnValue : &:r380_8, m381_13 +# 380| v380_10(void) = UnmodeledUse : mu* +# 380| v380_11(void) = AliasedUse : ~mu380_3 +# 380| v380_12(void) = ExitFunction : + +# 384| void Switch(int) +# 384| Block 0 +# 384| v384_1(void) = EnterFunction : +# 384| mu384_2(unknown) = AliasedDefinition : +# 384| mu384_3(unknown) = UnmodeledDefinition : +# 384| r384_4(glval) = VariableAddress[x] : +# 384| m384_5(int) = InitializeParameter[x] : &:r384_4 +# 385| r385_1(glval) = VariableAddress[y] : +# 385| m385_2(int) = Uninitialized[y] : &:r385_1 +# 386| r386_1(glval) = VariableAddress[x] : +# 386| r386_2(int) = Load : &:r386_1, m384_5 +# 386| v386_3(void) = Switch : r386_2 +#-----| Case[-1] -> Block 1 +#-----| Case[1] -> Block 2 +#-----| Case[2] -> Block 3 +#-----| Case[3] -> Block 4 +#-----| Case[4] -> Block 5 +#-----| Default -> Block 6 + +# 389| Block 1 +# 389| v389_1(void) = NoOp : +# 390| r390_1(int) = Constant[-1] : +# 390| r390_2(glval) = VariableAddress[y] : +# 390| m390_3(int) = Store : &:r390_2, r390_1 +# 391| v391_1(void) = NoOp : +#-----| Goto -> Block 7 + +# 393| Block 2 +# 393| v393_1(void) = NoOp : +#-----| Goto -> Block 3 + +# 394| Block 3 +# 394| v394_1(void) = NoOp : +# 395| r395_1(int) = Constant[1] : +# 395| r395_2(glval) = VariableAddress[y] : +# 395| m395_3(int) = Store : &:r395_2, r395_1 +# 396| v396_1(void) = NoOp : +#-----| Goto -> Block 7 + +# 398| Block 4 +# 398| v398_1(void) = NoOp : +# 399| r399_1(int) = Constant[3] : +# 399| r399_2(glval) = VariableAddress[y] : +# 399| m399_3(int) = Store : &:r399_2, r399_1 +#-----| Goto -> Block 5 + +# 400| Block 5 +# 400| v400_1(void) = NoOp : +# 401| r401_1(int) = Constant[4] : +# 401| r401_2(glval) = VariableAddress[y] : +# 401| m401_3(int) = Store : &:r401_2, r401_1 +# 402| v402_1(void) = NoOp : +#-----| Goto -> Block 7 + +# 404| Block 6 +# 404| v404_1(void) = NoOp : +# 405| r405_1(int) = Constant[0] : +# 405| r405_2(glval) = VariableAddress[y] : +# 405| m405_3(int) = Store : &:r405_2, r405_1 +# 406| v406_1(void) = NoOp : +#-----| Goto -> Block 7 + +# 409| Block 7 +# 409| v409_1(void) = NoOp : +# 410| v410_1(void) = NoOp : +# 384| v384_6(void) = ReturnVoid : +# 384| v384_7(void) = UnmodeledUse : mu* +# 384| v384_8(void) = AliasedUse : ~mu384_3 +# 384| v384_9(void) = ExitFunction : + +# 422| Point ReturnStruct(Point) +# 422| Block 0 +# 422| v422_1(void) = EnterFunction : +# 422| mu422_2(unknown) = AliasedDefinition : +# 422| mu422_3(unknown) = UnmodeledDefinition : +# 422| r422_4(glval) = VariableAddress[pt] : +# 422| m422_5(Point) = InitializeParameter[pt] : &:r422_4 +# 423| r423_1(glval) = VariableAddress[#return] : +# 423| r423_2(glval) = VariableAddress[pt] : +# 423| r423_3(Point) = Load : &:r423_2, m422_5 +# 423| m423_4(Point) = Store : &:r423_1, r423_3 +# 422| r422_6(glval) = VariableAddress[#return] : +# 422| v422_7(void) = ReturnValue : &:r422_6, m423_4 +# 422| v422_8(void) = UnmodeledUse : mu* +# 422| v422_9(void) = AliasedUse : ~mu422_3 +# 422| v422_10(void) = ExitFunction : + +# 426| void FieldAccess() +# 426| Block 0 +# 426| v426_1(void) = EnterFunction : +# 426| mu426_2(unknown) = AliasedDefinition : +# 426| mu426_3(unknown) = UnmodeledDefinition : +# 427| r427_1(glval) = VariableAddress[pt] : +# 427| mu427_2(Point) = Uninitialized[pt] : &:r427_1 +# 428| r428_1(int) = Constant[5] : +# 428| r428_2(glval) = VariableAddress[pt] : +# 428| r428_3(glval) = FieldAddress[x] : r428_2 +# 428| mu428_4(int) = Store : &:r428_3, r428_1 +# 429| r429_1(glval) = VariableAddress[pt] : +# 429| r429_2(glval) = FieldAddress[x] : r429_1 +# 429| r429_3(int) = Load : &:r429_2, ~mu426_3 +# 429| r429_4(glval) = VariableAddress[pt] : +# 429| r429_5(glval) = FieldAddress[y] : r429_4 +# 429| mu429_6(int) = Store : &:r429_5, r429_3 +# 430| r430_1(glval) = VariableAddress[p] : +# 430| r430_2(glval) = VariableAddress[pt] : +# 430| r430_3(glval) = FieldAddress[y] : r430_2 +# 430| r430_4(int *) = CopyValue : r430_3 +# 430| m430_5(int *) = Store : &:r430_1, r430_4 +# 431| v431_1(void) = NoOp : +# 426| v426_4(void) = ReturnVoid : +# 426| v426_5(void) = UnmodeledUse : mu* +# 426| v426_6(void) = AliasedUse : ~mu426_3 +# 426| v426_7(void) = ExitFunction : + +# 433| void LogicalOr(bool, bool) +# 433| Block 0 +# 433| v433_1(void) = EnterFunction : +# 433| mu433_2(unknown) = AliasedDefinition : +# 433| mu433_3(unknown) = UnmodeledDefinition : +# 433| r433_4(glval) = VariableAddress[a] : +# 433| m433_5(bool) = InitializeParameter[a] : &:r433_4 +# 433| r433_6(glval) = VariableAddress[b] : +# 433| m433_7(bool) = InitializeParameter[b] : &:r433_6 +# 434| r434_1(glval) = VariableAddress[x] : +# 434| m434_2(int) = Uninitialized[x] : &:r434_1 +# 435| r435_1(glval) = VariableAddress[a] : +# 435| r435_2(bool) = Load : &:r435_1, m433_5 +# 435| v435_3(void) = ConditionalBranch : r435_2 +#-----| False -> Block 1 +#-----| True -> Block 2 + +# 435| Block 1 +# 435| r435_4(glval) = VariableAddress[b] : +# 435| r435_5(bool) = Load : &:r435_4, m433_7 +# 435| v435_6(void) = ConditionalBranch : r435_5 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 436| Block 2 +# 436| r436_1(int) = Constant[7] : +# 436| r436_2(glval) = VariableAddress[x] : +# 436| m436_3(int) = Store : &:r436_2, r436_1 +#-----| Goto -> Block 3 + +# 439| Block 3 +# 439| r439_1(glval) = VariableAddress[a] : +# 439| r439_2(bool) = Load : &:r439_1, m433_5 +# 439| v439_3(void) = ConditionalBranch : r439_2 +#-----| False -> Block 4 +#-----| True -> Block 5 + +# 439| Block 4 +# 439| r439_4(glval) = VariableAddress[b] : +# 439| r439_5(bool) = Load : &:r439_4, m433_7 +# 439| v439_6(void) = ConditionalBranch : r439_5 +#-----| False -> Block 6 +#-----| True -> Block 5 + +# 440| Block 5 +# 440| r440_1(int) = Constant[1] : +# 440| r440_2(glval) = VariableAddress[x] : +# 440| m440_3(int) = Store : &:r440_2, r440_1 +#-----| Goto -> Block 7 + +# 443| Block 6 +# 443| r443_1(int) = Constant[5] : +# 443| r443_2(glval) = VariableAddress[x] : +# 443| m443_3(int) = Store : &:r443_2, r443_1 +#-----| Goto -> Block 7 + +# 445| Block 7 +# 445| v445_1(void) = NoOp : +# 433| v433_8(void) = ReturnVoid : +# 433| v433_9(void) = UnmodeledUse : mu* +# 433| v433_10(void) = AliasedUse : ~mu433_3 +# 433| v433_11(void) = ExitFunction : + +# 447| void LogicalAnd(bool, bool) +# 447| Block 0 +# 447| v447_1(void) = EnterFunction : +# 447| mu447_2(unknown) = AliasedDefinition : +# 447| mu447_3(unknown) = UnmodeledDefinition : +# 447| r447_4(glval) = VariableAddress[a] : +# 447| m447_5(bool) = InitializeParameter[a] : &:r447_4 +# 447| r447_6(glval) = VariableAddress[b] : +# 447| m447_7(bool) = InitializeParameter[b] : &:r447_6 +# 448| r448_1(glval) = VariableAddress[x] : +# 448| m448_2(int) = Uninitialized[x] : &:r448_1 +# 449| r449_1(glval) = VariableAddress[a] : +# 449| r449_2(bool) = Load : &:r449_1, m447_5 +# 449| v449_3(void) = ConditionalBranch : r449_2 +#-----| False -> Block 3 +#-----| True -> Block 1 + +# 449| Block 1 +# 449| r449_4(glval) = VariableAddress[b] : +# 449| r449_5(bool) = Load : &:r449_4, m447_7 +# 449| v449_6(void) = ConditionalBranch : r449_5 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 450| Block 2 +# 450| r450_1(int) = Constant[7] : +# 450| r450_2(glval) = VariableAddress[x] : +# 450| m450_3(int) = Store : &:r450_2, r450_1 +#-----| Goto -> Block 3 + +# 453| Block 3 +# 453| r453_1(glval) = VariableAddress[a] : +# 453| r453_2(bool) = Load : &:r453_1, m447_5 +# 453| v453_3(void) = ConditionalBranch : r453_2 +#-----| False -> Block 6 +#-----| True -> Block 4 + +# 453| Block 4 +# 453| r453_4(glval) = VariableAddress[b] : +# 453| r453_5(bool) = Load : &:r453_4, m447_7 +# 453| v453_6(void) = ConditionalBranch : r453_5 +#-----| False -> Block 6 +#-----| True -> Block 5 + +# 454| Block 5 +# 454| r454_1(int) = Constant[1] : +# 454| r454_2(glval) = VariableAddress[x] : +# 454| m454_3(int) = Store : &:r454_2, r454_1 +#-----| Goto -> Block 7 + +# 457| Block 6 +# 457| r457_1(int) = Constant[5] : +# 457| r457_2(glval) = VariableAddress[x] : +# 457| m457_3(int) = Store : &:r457_2, r457_1 +#-----| Goto -> Block 7 + +# 459| Block 7 +# 459| v459_1(void) = NoOp : +# 447| v447_8(void) = ReturnVoid : +# 447| v447_9(void) = UnmodeledUse : mu* +# 447| v447_10(void) = AliasedUse : ~mu447_3 +# 447| v447_11(void) = ExitFunction : + +# 461| void LogicalNot(bool, bool) +# 461| Block 0 +# 461| v461_1(void) = EnterFunction : +# 461| mu461_2(unknown) = AliasedDefinition : +# 461| mu461_3(unknown) = UnmodeledDefinition : +# 461| r461_4(glval) = VariableAddress[a] : +# 461| m461_5(bool) = InitializeParameter[a] : &:r461_4 +# 461| r461_6(glval) = VariableAddress[b] : +# 461| m461_7(bool) = InitializeParameter[b] : &:r461_6 +# 462| r462_1(glval) = VariableAddress[x] : +# 462| m462_2(int) = Uninitialized[x] : &:r462_1 +# 463| r463_1(glval) = VariableAddress[a] : +# 463| r463_2(bool) = Load : &:r463_1, m461_5 +# 463| v463_3(void) = ConditionalBranch : r463_2 +#-----| False -> Block 1 +#-----| True -> Block 2 + +# 464| Block 1 +# 464| r464_1(int) = Constant[1] : +# 464| r464_2(glval) = VariableAddress[x] : +# 464| m464_3(int) = Store : &:r464_2, r464_1 +#-----| Goto -> Block 2 + +# 467| Block 2 +# 467| r467_1(glval) = VariableAddress[a] : +# 467| r467_2(bool) = Load : &:r467_1, m461_5 +# 467| v467_3(void) = ConditionalBranch : r467_2 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 467| Block 3 +# 467| r467_4(glval) = VariableAddress[b] : +# 467| r467_5(bool) = Load : &:r467_4, m461_7 +# 467| v467_6(void) = ConditionalBranch : r467_5 +#-----| False -> Block 4 +#-----| True -> Block 5 + +# 468| Block 4 +# 468| r468_1(int) = Constant[2] : +# 468| r468_2(glval) = VariableAddress[x] : +# 468| m468_3(int) = Store : &:r468_2, r468_1 +#-----| Goto -> Block 6 + +# 471| Block 5 +# 471| r471_1(int) = Constant[3] : +# 471| r471_2(glval) = VariableAddress[x] : +# 471| m471_3(int) = Store : &:r471_2, r471_1 +#-----| Goto -> Block 6 + +# 473| Block 6 +# 473| v473_1(void) = NoOp : +# 461| v461_8(void) = ReturnVoid : +# 461| v461_9(void) = UnmodeledUse : mu* +# 461| v461_10(void) = AliasedUse : ~mu461_3 +# 461| v461_11(void) = ExitFunction : + +# 475| void ConditionValues(bool, bool) +# 475| Block 0 +# 475| v475_1(void) = EnterFunction : +# 475| mu475_2(unknown) = AliasedDefinition : +# 475| mu475_3(unknown) = UnmodeledDefinition : +# 475| r475_4(glval) = VariableAddress[a] : +# 475| m475_5(bool) = InitializeParameter[a] : &:r475_4 +# 475| r475_6(glval) = VariableAddress[b] : +# 475| m475_7(bool) = InitializeParameter[b] : &:r475_6 +# 476| r476_1(glval) = VariableAddress[x] : +# 476| m476_2(bool) = Uninitialized[x] : &:r476_1 +# 477| r477_1(glval) = VariableAddress[a] : +# 477| r477_2(bool) = Load : &:r477_1, m475_5 +# 477| v477_3(void) = ConditionalBranch : r477_2 +#-----| False -> Block 10 +#-----| True -> Block 1 + +# 477| Block 1 +# 477| r477_4(glval) = VariableAddress[b] : +# 477| r477_5(bool) = Load : &:r477_4, m475_7 +# 477| v477_6(void) = ConditionalBranch : r477_5 +#-----| False -> Block 10 +#-----| True -> Block 12 + +# 478| Block 2 +# 478| r478_1(glval) = VariableAddress[#temp478:9] : +# 478| r478_2(bool) = Constant[0] : +# 478| m478_3(bool) = Store : &:r478_1, r478_2 +#-----| Goto -> Block 3 + +# 478| Block 3 +# 478| m478_4(bool) = Phi : from 2:m478_3, from 4:m478_11 +# 478| r478_5(glval) = VariableAddress[#temp478:9] : +# 478| r478_6(bool) = Load : &:r478_5, m478_4 +# 478| r478_7(glval) = VariableAddress[x] : +# 478| m478_8(bool) = Store : &:r478_7, r478_6 +# 479| r479_1(glval) = VariableAddress[a] : +# 479| r479_2(bool) = Load : &:r479_1, m475_5 +# 479| v479_3(void) = ConditionalBranch : r479_2 +#-----| False -> Block 9 +#-----| True -> Block 8 + +# 478| Block 4 +# 478| r478_9(glval) = VariableAddress[#temp478:9] : +# 478| r478_10(bool) = Constant[1] : +# 478| m478_11(bool) = Store : &:r478_9, r478_10 +#-----| Goto -> Block 3 + +# 478| Block 5 +# 478| r478_12(glval) = VariableAddress[b] : +# 478| r478_13(bool) = Load : &:r478_12, m475_7 +# 478| v478_14(void) = ConditionalBranch : r478_13 +#-----| False -> Block 2 +#-----| True -> Block 4 + +# 479| Block 6 +# 479| r479_4(glval) = VariableAddress[#temp479:11] : +# 479| r479_5(bool) = Constant[0] : +# 479| m479_6(bool) = Store : &:r479_4, r479_5 +#-----| Goto -> Block 7 + +# 479| Block 7 +# 479| m479_7(bool) = Phi : from 6:m479_6, from 8:m479_15 +# 479| r479_8(glval) = VariableAddress[#temp479:11] : +# 479| r479_9(bool) = Load : &:r479_8, m479_7 +# 479| r479_10(bool) = LogicalNot : r479_9 +# 479| r479_11(glval) = VariableAddress[x] : +# 479| m479_12(bool) = Store : &:r479_11, r479_10 +# 480| v480_1(void) = NoOp : +# 475| v475_8(void) = ReturnVoid : +# 475| v475_9(void) = UnmodeledUse : mu* +# 475| v475_10(void) = AliasedUse : ~mu475_3 +# 475| v475_11(void) = ExitFunction : + +# 479| Block 8 +# 479| r479_13(glval) = VariableAddress[#temp479:11] : +# 479| r479_14(bool) = Constant[1] : +# 479| m479_15(bool) = Store : &:r479_13, r479_14 +#-----| Goto -> Block 7 + +# 479| Block 9 +# 479| r479_16(glval) = VariableAddress[b] : +# 479| r479_17(bool) = Load : &:r479_16, m475_7 +# 479| v479_18(void) = ConditionalBranch : r479_17 +#-----| False -> Block 6 +#-----| True -> Block 8 + +# 477| Block 10 +# 477| r477_7(glval) = VariableAddress[#temp477:9] : +# 477| r477_8(bool) = Constant[0] : +# 477| m477_9(bool) = Store : &:r477_7, r477_8 +#-----| Goto -> Block 11 + +# 477| Block 11 +# 477| m477_10(bool) = Phi : from 10:m477_9, from 12:m477_17 +# 477| r477_11(glval) = VariableAddress[#temp477:9] : +# 477| r477_12(bool) = Load : &:r477_11, m477_10 +# 477| r477_13(glval) = VariableAddress[x] : +# 477| m477_14(bool) = Store : &:r477_13, r477_12 +# 478| r478_15(glval) = VariableAddress[a] : +# 478| r478_16(bool) = Load : &:r478_15, m475_5 +# 478| v478_17(void) = ConditionalBranch : r478_16 +#-----| False -> Block 5 +#-----| True -> Block 4 + +# 477| Block 12 +# 477| r477_15(glval) = VariableAddress[#temp477:9] : +# 477| r477_16(bool) = Constant[1] : +# 477| m477_17(bool) = Store : &:r477_15, r477_16 +#-----| Goto -> Block 11 + +# 482| void Conditional(bool, int, int) +# 482| Block 0 +# 482| v482_1(void) = EnterFunction : +# 482| mu482_2(unknown) = AliasedDefinition : +# 482| mu482_3(unknown) = UnmodeledDefinition : +# 482| r482_4(glval) = VariableAddress[a] : +# 482| m482_5(bool) = InitializeParameter[a] : &:r482_4 +# 482| r482_6(glval) = VariableAddress[x] : +# 482| m482_7(int) = InitializeParameter[x] : &:r482_6 +# 482| r482_8(glval) = VariableAddress[y] : +# 482| m482_9(int) = InitializeParameter[y] : &:r482_8 +# 483| r483_1(glval) = VariableAddress[z] : +# 483| r483_2(glval) = VariableAddress[a] : +# 483| r483_3(bool) = Load : &:r483_2, m482_5 +# 483| v483_4(void) = ConditionalBranch : r483_3 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 483| Block 1 +# 483| r483_5(glval) = VariableAddress[x] : +# 483| r483_6(int) = Load : &:r483_5, m482_7 +# 483| r483_7(glval) = VariableAddress[#temp483:13] : +# 483| m483_8(int) = Store : &:r483_7, r483_6 +#-----| Goto -> Block 3 + +# 483| Block 2 +# 483| r483_9(glval) = VariableAddress[y] : +# 483| r483_10(int) = Load : &:r483_9, m482_9 +# 483| r483_11(glval) = VariableAddress[#temp483:13] : +# 483| m483_12(int) = Store : &:r483_11, r483_10 +#-----| Goto -> Block 3 + +# 483| Block 3 +# 483| m483_13(int) = Phi : from 1:m483_8, from 2:m483_12 +# 483| r483_14(glval) = VariableAddress[#temp483:13] : +# 483| r483_15(int) = Load : &:r483_14, m483_13 +# 483| m483_16(int) = Store : &:r483_1, r483_15 +# 484| v484_1(void) = NoOp : +# 482| v482_10(void) = ReturnVoid : +# 482| v482_11(void) = UnmodeledUse : mu* +# 482| v482_12(void) = AliasedUse : ~mu482_3 +# 482| v482_13(void) = ExitFunction : + +# 486| void Conditional_LValue(bool) +# 486| Block 0 +# 486| v486_1(void) = EnterFunction : +# 486| mu486_2(unknown) = AliasedDefinition : +# 486| mu486_3(unknown) = UnmodeledDefinition : +# 486| r486_4(glval) = VariableAddress[a] : +# 486| m486_5(bool) = InitializeParameter[a] : &:r486_4 +# 487| r487_1(glval) = VariableAddress[x] : +# 487| m487_2(int) = Uninitialized[x] : &:r487_1 +# 488| r488_1(glval) = VariableAddress[y] : +# 488| m488_2(int) = Uninitialized[y] : &:r488_1 +# 489| r489_1(int) = Constant[5] : +# 489| r489_2(glval) = VariableAddress[a] : +# 489| r489_3(bool) = Load : &:r489_2, m486_5 +# 489| v489_4(void) = ConditionalBranch : r489_3 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 489| Block 1 +# 489| m489_5(glval) = Phi : from 2:m489_11, from 3:m489_14 +# 489| r489_6(glval) = VariableAddress[#temp489:6] : +# 489| r489_7(glval) = Load : &:r489_6, m489_5 +# 489| mu489_8(int) = Store : &:r489_7, r489_1 +# 490| v490_1(void) = NoOp : +# 486| v486_6(void) = ReturnVoid : +# 486| v486_7(void) = UnmodeledUse : mu* +# 486| v486_8(void) = AliasedUse : ~mu486_3 +# 486| v486_9(void) = ExitFunction : + +# 489| Block 2 +# 489| r489_9(glval) = VariableAddress[x] : +# 489| r489_10(glval) = VariableAddress[#temp489:6] : +# 489| m489_11(glval) = Store : &:r489_10, r489_9 +#-----| Goto -> Block 1 + +# 489| Block 3 +# 489| r489_12(glval) = VariableAddress[y] : +# 489| r489_13(glval) = VariableAddress[#temp489:6] : +# 489| m489_14(glval) = Store : &:r489_13, r489_12 +#-----| Goto -> Block 1 + +# 492| void Conditional_Void(bool) +# 492| Block 0 +# 492| v492_1(void) = EnterFunction : +# 492| mu492_2(unknown) = AliasedDefinition : +# 492| mu492_3(unknown) = UnmodeledDefinition : +# 492| r492_4(glval) = VariableAddress[a] : +# 492| m492_5(bool) = InitializeParameter[a] : &:r492_4 +# 493| r493_1(glval) = VariableAddress[a] : +# 493| r493_2(bool) = Load : &:r493_1, m492_5 +# 493| v493_3(void) = ConditionalBranch : r493_2 +#-----| False -> Block 1 +#-----| True -> Block 3 + +# 493| Block 1 +# 493| r493_4(glval) = FunctionAddress[VoidFunc] : +# 493| v493_5(void) = Call : func:r493_4 +# 493| mu493_6(unknown) = ^CallSideEffect : ~mu492_3 +#-----| Goto -> Block 2 + +# 494| Block 2 +# 494| v494_1(void) = NoOp : +# 492| v492_6(void) = ReturnVoid : +# 492| v492_7(void) = UnmodeledUse : mu* +# 492| v492_8(void) = AliasedUse : ~mu492_3 +# 492| v492_9(void) = ExitFunction : + +# 493| Block 3 +# 493| r493_7(glval) = FunctionAddress[VoidFunc] : +# 493| v493_8(void) = Call : func:r493_7 +# 493| mu493_9(unknown) = ^CallSideEffect : ~mu492_3 +#-----| Goto -> Block 2 + +# 496| void Nullptr() +# 496| Block 0 +# 496| v496_1(void) = EnterFunction : +# 496| mu496_2(unknown) = AliasedDefinition : +# 496| mu496_3(unknown) = UnmodeledDefinition : +# 497| r497_1(glval) = VariableAddress[p] : +# 497| r497_2(int *) = Constant[0] : +# 497| m497_3(int *) = Store : &:r497_1, r497_2 +# 498| r498_1(glval) = VariableAddress[q] : +# 498| r498_2(int *) = Constant[0] : +# 498| m498_3(int *) = Store : &:r498_1, r498_2 +# 499| r499_1(int *) = Constant[0] : +# 499| r499_2(glval) = VariableAddress[p] : +# 499| m499_3(int *) = Store : &:r499_2, r499_1 +# 500| r500_1(int *) = Constant[0] : +# 500| r500_2(glval) = VariableAddress[q] : +# 500| m500_3(int *) = Store : &:r500_2, r500_1 +# 501| v501_1(void) = NoOp : +# 496| v496_4(void) = ReturnVoid : +# 496| v496_5(void) = UnmodeledUse : mu* +# 496| v496_6(void) = AliasedUse : ~mu496_3 +# 496| v496_7(void) = ExitFunction : + +# 503| void InitList(int, float) +# 503| Block 0 +# 503| v503_1(void) = EnterFunction : +# 503| mu503_2(unknown) = AliasedDefinition : +# 503| mu503_3(unknown) = UnmodeledDefinition : +# 503| r503_4(glval) = VariableAddress[x] : +# 503| m503_5(int) = InitializeParameter[x] : &:r503_4 +# 503| r503_6(glval) = VariableAddress[f] : +# 503| m503_7(float) = InitializeParameter[f] : &:r503_6 +# 504| r504_1(glval) = VariableAddress[pt1] : +# 504| mu504_2(Point) = Uninitialized[pt1] : &:r504_1 +# 504| r504_3(glval) = FieldAddress[x] : r504_1 +# 504| r504_4(glval) = VariableAddress[x] : +# 504| r504_5(int) = Load : &:r504_4, m503_5 +# 504| mu504_6(int) = Store : &:r504_3, r504_5 +# 504| r504_7(glval) = FieldAddress[y] : r504_1 +# 504| r504_8(glval) = VariableAddress[f] : +# 504| r504_9(float) = Load : &:r504_8, m503_7 +# 504| r504_10(int) = Convert : r504_9 +# 504| mu504_11(int) = Store : &:r504_7, r504_10 +# 505| r505_1(glval) = VariableAddress[pt2] : +# 505| mu505_2(Point) = Uninitialized[pt2] : &:r505_1 +# 505| r505_3(glval) = FieldAddress[x] : r505_1 +# 505| r505_4(glval) = VariableAddress[x] : +# 505| r505_5(int) = Load : &:r505_4, m503_5 +# 505| mu505_6(int) = Store : &:r505_3, r505_5 +# 505| r505_7(glval) = FieldAddress[y] : r505_1 +# 505| r505_8(int) = Constant[0] : +# 505| mu505_9(int) = Store : &:r505_7, r505_8 +# 506| r506_1(glval) = VariableAddress[pt3] : +# 506| mu506_2(Point) = Uninitialized[pt3] : &:r506_1 +# 506| r506_3(glval) = FieldAddress[x] : r506_1 +# 506| r506_4(int) = Constant[0] : +# 506| mu506_5(int) = Store : &:r506_3, r506_4 +# 506| r506_6(glval) = FieldAddress[y] : r506_1 +# 506| r506_7(int) = Constant[0] : +# 506| mu506_8(int) = Store : &:r506_6, r506_7 +# 508| r508_1(glval) = VariableAddress[x1] : +# 508| r508_2(int) = Constant[1] : +# 508| m508_3(int) = Store : &:r508_1, r508_2 +# 509| r509_1(glval) = VariableAddress[x2] : +# 509| r509_2(int) = Constant[0] : +# 509| m509_3(int) = Store : &:r509_1, r509_2 +# 510| v510_1(void) = NoOp : +# 503| v503_8(void) = ReturnVoid : +# 503| v503_9(void) = UnmodeledUse : mu* +# 503| v503_10(void) = AliasedUse : ~mu503_3 +# 503| v503_11(void) = ExitFunction : + +# 512| void NestedInitList(int, float) +# 512| Block 0 +# 512| v512_1(void) = EnterFunction : +# 512| mu512_2(unknown) = AliasedDefinition : +# 512| mu512_3(unknown) = UnmodeledDefinition : +# 512| r512_4(glval) = VariableAddress[x] : +# 512| m512_5(int) = InitializeParameter[x] : &:r512_4 +# 512| r512_6(glval) = VariableAddress[f] : +# 512| m512_7(float) = InitializeParameter[f] : &:r512_6 +# 513| r513_1(glval) = VariableAddress[r1] : +# 513| mu513_2(Rect) = Uninitialized[r1] : &:r513_1 +# 513| r513_3(glval) = FieldAddress[topLeft] : r513_1 +# 513| r513_4(Point) = Constant[0] : +# 513| mu513_5(Point) = Store : &:r513_3, r513_4 +# 513| r513_6(glval) = FieldAddress[bottomRight] : r513_1 +# 513| r513_7(Point) = Constant[0] : +# 513| mu513_8(Point) = Store : &:r513_6, r513_7 +# 514| r514_1(glval) = VariableAddress[r2] : +# 514| mu514_2(Rect) = Uninitialized[r2] : &:r514_1 +# 514| r514_3(glval) = FieldAddress[topLeft] : r514_1 +# 514| r514_4(glval) = FieldAddress[x] : r514_3 +# 514| r514_5(glval) = VariableAddress[x] : +# 514| r514_6(int) = Load : &:r514_5, m512_5 +# 514| mu514_7(int) = Store : &:r514_4, r514_6 +# 514| r514_8(glval) = FieldAddress[y] : r514_3 +# 514| r514_9(glval) = VariableAddress[f] : +# 514| r514_10(float) = Load : &:r514_9, m512_7 +# 514| r514_11(int) = Convert : r514_10 +# 514| mu514_12(int) = Store : &:r514_8, r514_11 +# 514| r514_13(glval) = FieldAddress[bottomRight] : r514_1 +# 514| r514_14(Point) = Constant[0] : +# 514| mu514_15(Point) = Store : &:r514_13, r514_14 +# 515| r515_1(glval) = VariableAddress[r3] : +# 515| mu515_2(Rect) = Uninitialized[r3] : &:r515_1 +# 515| r515_3(glval) = FieldAddress[topLeft] : r515_1 +# 515| r515_4(glval) = FieldAddress[x] : r515_3 +# 515| r515_5(glval) = VariableAddress[x] : +# 515| r515_6(int) = Load : &:r515_5, m512_5 +# 515| mu515_7(int) = Store : &:r515_4, r515_6 +# 515| r515_8(glval) = FieldAddress[y] : r515_3 +# 515| r515_9(glval) = VariableAddress[f] : +# 515| r515_10(float) = Load : &:r515_9, m512_7 +# 515| r515_11(int) = Convert : r515_10 +# 515| mu515_12(int) = Store : &:r515_8, r515_11 +# 515| r515_13(glval) = FieldAddress[bottomRight] : r515_1 +# 515| r515_14(glval) = FieldAddress[x] : r515_13 +# 515| r515_15(glval) = VariableAddress[x] : +# 515| r515_16(int) = Load : &:r515_15, m512_5 +# 515| mu515_17(int) = Store : &:r515_14, r515_16 +# 515| r515_18(glval) = FieldAddress[y] : r515_13 +# 515| r515_19(glval) = VariableAddress[f] : +# 515| r515_20(float) = Load : &:r515_19, m512_7 +# 515| r515_21(int) = Convert : r515_20 +# 515| mu515_22(int) = Store : &:r515_18, r515_21 +# 516| r516_1(glval) = VariableAddress[r4] : +# 516| mu516_2(Rect) = Uninitialized[r4] : &:r516_1 +# 516| r516_3(glval) = FieldAddress[topLeft] : r516_1 +# 516| r516_4(glval) = FieldAddress[x] : r516_3 +# 516| r516_5(glval) = VariableAddress[x] : +# 516| r516_6(int) = Load : &:r516_5, m512_5 +# 516| mu516_7(int) = Store : &:r516_4, r516_6 +# 516| r516_8(glval) = FieldAddress[y] : r516_3 +# 516| r516_9(int) = Constant[0] : +# 516| mu516_10(int) = Store : &:r516_8, r516_9 +# 516| r516_11(glval) = FieldAddress[bottomRight] : r516_1 +# 516| r516_12(glval) = FieldAddress[x] : r516_11 +# 516| r516_13(glval) = VariableAddress[x] : +# 516| r516_14(int) = Load : &:r516_13, m512_5 +# 516| mu516_15(int) = Store : &:r516_12, r516_14 +# 516| r516_16(glval) = FieldAddress[y] : r516_11 +# 516| r516_17(int) = Constant[0] : +# 516| mu516_18(int) = Store : &:r516_16, r516_17 +# 517| v517_1(void) = NoOp : +# 512| v512_8(void) = ReturnVoid : +# 512| v512_9(void) = UnmodeledUse : mu* +# 512| v512_10(void) = AliasedUse : ~mu512_3 +# 512| v512_11(void) = ExitFunction : + +# 519| void ArrayInit(int, float) +# 519| Block 0 +# 519| v519_1(void) = EnterFunction : +# 519| mu519_2(unknown) = AliasedDefinition : +# 519| mu519_3(unknown) = UnmodeledDefinition : +# 519| r519_4(glval) = VariableAddress[x] : +# 519| m519_5(int) = InitializeParameter[x] : &:r519_4 +# 519| r519_6(glval) = VariableAddress[f] : +# 519| m519_7(float) = InitializeParameter[f] : &:r519_6 +# 520| r520_1(glval) = VariableAddress[a1] : +# 520| mu520_2(int[3]) = Uninitialized[a1] : &:r520_1 +# 520| r520_3(int) = Constant[0] : +# 520| r520_4(glval) = PointerAdd[4] : r520_1, r520_3 +# 520| r520_5(unknown[12]) = Constant[0] : +# 520| mu520_6(unknown[12]) = Store : &:r520_4, r520_5 +# 521| r521_1(glval) = VariableAddress[a2] : +# 521| mu521_2(int[3]) = Uninitialized[a2] : &:r521_1 +# 521| r521_3(int) = Constant[0] : +# 521| r521_4(glval) = PointerAdd[4] : r521_1, r521_3 +# 521| r521_5(glval) = VariableAddress[x] : +# 521| r521_6(int) = Load : &:r521_5, m519_5 +# 521| mu521_7(int) = Store : &:r521_4, r521_6 +# 521| r521_8(int) = Constant[1] : +# 521| r521_9(glval) = PointerAdd[4] : r521_1, r521_8 +# 521| r521_10(glval) = VariableAddress[f] : +# 521| r521_11(float) = Load : &:r521_10, m519_7 +# 521| r521_12(int) = Convert : r521_11 +# 521| mu521_13(int) = Store : &:r521_9, r521_12 +# 521| r521_14(int) = Constant[2] : +# 521| r521_15(glval) = PointerAdd[4] : r521_1, r521_14 +# 521| r521_16(int) = Constant[0] : +# 521| mu521_17(int) = Store : &:r521_15, r521_16 +# 522| r522_1(glval) = VariableAddress[a3] : +# 522| mu522_2(int[3]) = Uninitialized[a3] : &:r522_1 +# 522| r522_3(int) = Constant[0] : +# 522| r522_4(glval) = PointerAdd[4] : r522_1, r522_3 +# 522| r522_5(glval) = VariableAddress[x] : +# 522| r522_6(int) = Load : &:r522_5, m519_5 +# 522| mu522_7(int) = Store : &:r522_4, r522_6 +# 522| r522_8(int) = Constant[1] : +# 522| r522_9(glval) = PointerAdd[4] : r522_1, r522_8 +# 522| r522_10(unknown[8]) = Constant[0] : +# 522| mu522_11(unknown[8]) = Store : &:r522_9, r522_10 +# 523| v523_1(void) = NoOp : +# 519| v519_8(void) = ReturnVoid : +# 519| v519_9(void) = UnmodeledUse : mu* +# 519| v519_10(void) = AliasedUse : ~mu519_3 +# 519| v519_11(void) = ExitFunction : + +# 530| void UnionInit(int, float) +# 530| Block 0 +# 530| v530_1(void) = EnterFunction : +# 530| mu530_2(unknown) = AliasedDefinition : +# 530| mu530_3(unknown) = UnmodeledDefinition : +# 530| r530_4(glval) = VariableAddress[x] : +# 530| m530_5(int) = InitializeParameter[x] : &:r530_4 +# 530| r530_6(glval) = VariableAddress[f] : +# 530| m530_7(float) = InitializeParameter[f] : &:r530_6 +# 531| r531_1(glval) = VariableAddress[u1] : +# 531| mu531_2(U) = Uninitialized[u1] : &:r531_1 +# 531| r531_3(glval) = FieldAddress[d] : r531_1 +# 531| r531_4(glval) = VariableAddress[f] : +# 531| r531_5(float) = Load : &:r531_4, m530_7 +# 531| r531_6(double) = Convert : r531_5 +# 531| mu531_7(double) = Store : &:r531_3, r531_6 +# 533| v533_1(void) = NoOp : +# 530| v530_8(void) = ReturnVoid : +# 530| v530_9(void) = UnmodeledUse : mu* +# 530| v530_10(void) = AliasedUse : ~mu530_3 +# 530| v530_11(void) = ExitFunction : + +# 535| void EarlyReturn(int, int) +# 535| Block 0 +# 535| v535_1(void) = EnterFunction : +# 535| mu535_2(unknown) = AliasedDefinition : +# 535| mu535_3(unknown) = UnmodeledDefinition : +# 535| r535_4(glval) = VariableAddress[x] : +# 535| m535_5(int) = InitializeParameter[x] : &:r535_4 +# 535| r535_6(glval) = VariableAddress[y] : +# 535| m535_7(int) = InitializeParameter[y] : &:r535_6 +# 536| r536_1(glval) = VariableAddress[x] : +# 536| r536_2(int) = Load : &:r536_1, m535_5 +# 536| r536_3(glval) = VariableAddress[y] : +# 536| r536_4(int) = Load : &:r536_3, m535_7 +# 536| r536_5(bool) = CompareLT : r536_2, r536_4 +# 536| v536_6(void) = ConditionalBranch : r536_5 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 535| Block 1 +# 535| v535_8(void) = ReturnVoid : +# 535| v535_9(void) = UnmodeledUse : mu* +# 535| v535_10(void) = AliasedUse : ~mu535_3 +# 535| v535_11(void) = ExitFunction : + +# 537| Block 2 +# 537| v537_1(void) = NoOp : +#-----| Goto -> Block 1 + +# 540| Block 3 +# 540| r540_1(glval) = VariableAddress[x] : +# 540| r540_2(int) = Load : &:r540_1, m535_5 +# 540| r540_3(glval) = VariableAddress[y] : +# 540| m540_4(int) = Store : &:r540_3, r540_2 +# 541| v541_1(void) = NoOp : +#-----| Goto -> Block 1 + +# 543| int EarlyReturnValue(int, int) +# 543| Block 0 +# 543| v543_1(void) = EnterFunction : +# 543| mu543_2(unknown) = AliasedDefinition : +# 543| mu543_3(unknown) = UnmodeledDefinition : +# 543| r543_4(glval) = VariableAddress[x] : +# 543| m543_5(int) = InitializeParameter[x] : &:r543_4 +# 543| r543_6(glval) = VariableAddress[y] : +# 543| m543_7(int) = InitializeParameter[y] : &:r543_6 +# 544| r544_1(glval) = VariableAddress[x] : +# 544| r544_2(int) = Load : &:r544_1, m543_5 +# 544| r544_3(glval) = VariableAddress[y] : +# 544| r544_4(int) = Load : &:r544_3, m543_7 +# 544| r544_5(bool) = CompareLT : r544_2, r544_4 +# 544| v544_6(void) = ConditionalBranch : r544_5 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 543| Block 1 +# 543| m543_8(int) = Phi : from 2:m545_4, from 3:m548_7 +# 543| r543_9(glval) = VariableAddress[#return] : +# 543| v543_10(void) = ReturnValue : &:r543_9, m543_8 +# 543| v543_11(void) = UnmodeledUse : mu* +# 543| v543_12(void) = AliasedUse : ~mu543_3 +# 543| v543_13(void) = ExitFunction : + +# 545| Block 2 +# 545| r545_1(glval) = VariableAddress[#return] : +# 545| r545_2(glval) = VariableAddress[x] : +# 545| r545_3(int) = Load : &:r545_2, m543_5 +# 545| m545_4(int) = Store : &:r545_1, r545_3 +#-----| Goto -> Block 1 + +# 548| Block 3 +# 548| r548_1(glval) = VariableAddress[#return] : +# 548| r548_2(glval) = VariableAddress[x] : +# 548| r548_3(int) = Load : &:r548_2, m543_5 +# 548| r548_4(glval) = VariableAddress[y] : +# 548| r548_5(int) = Load : &:r548_4, m543_7 +# 548| r548_6(int) = Add : r548_3, r548_5 +# 548| m548_7(int) = Store : &:r548_1, r548_6 +#-----| Goto -> Block 1 + +# 551| int CallViaFuncPtr(int(*)(int)) +# 551| Block 0 +# 551| v551_1(void) = EnterFunction : +# 551| mu551_2(unknown) = AliasedDefinition : +# 551| mu551_3(unknown) = UnmodeledDefinition : +# 551| r551_4(glval<..(*)(..)>) = VariableAddress[pfn] : +# 551| m551_5(..(*)(..)) = InitializeParameter[pfn] : &:r551_4 +# 552| r552_1(glval) = VariableAddress[#return] : +# 552| r552_2(glval<..(*)(..)>) = VariableAddress[pfn] : +# 552| r552_3(..(*)(..)) = Load : &:r552_2, m551_5 +# 552| r552_4(int) = Constant[5] : +# 552| r552_5(int) = Call : func:r552_3, 0:r552_4 +# 552| mu552_6(unknown) = ^CallSideEffect : ~mu551_3 +# 552| m552_7(int) = Store : &:r552_1, r552_5 +# 551| r551_6(glval) = VariableAddress[#return] : +# 551| v551_7(void) = ReturnValue : &:r551_6, m552_7 +# 551| v551_8(void) = UnmodeledUse : mu* +# 551| v551_9(void) = AliasedUse : ~mu551_3 +# 551| v551_10(void) = ExitFunction : + +# 560| int EnumSwitch(E) +# 560| Block 0 +# 560| v560_1(void) = EnterFunction : +# 560| mu560_2(unknown) = AliasedDefinition : +# 560| mu560_3(unknown) = UnmodeledDefinition : +# 560| r560_4(glval) = VariableAddress[e] : +# 560| m560_5(E) = InitializeParameter[e] : &:r560_4 +# 561| r561_1(glval) = VariableAddress[e] : +# 561| r561_2(E) = Load : &:r561_1, m560_5 +# 561| r561_3(int) = Convert : r561_2 +# 561| v561_4(void) = Switch : r561_3 +#-----| Case[0] -> Block 4 +#-----| Case[1] -> Block 2 +#-----| Default -> Block 3 + +# 560| Block 1 +# 560| m560_6(int) = Phi : from 2:m565_3, from 3:m567_3, from 4:m563_3 +# 560| r560_7(glval) = VariableAddress[#return] : +# 560| v560_8(void) = ReturnValue : &:r560_7, m560_6 +# 560| v560_9(void) = UnmodeledUse : mu* +# 560| v560_10(void) = AliasedUse : ~mu560_3 +# 560| v560_11(void) = ExitFunction : + +# 564| Block 2 +# 564| v564_1(void) = NoOp : +# 565| r565_1(glval) = VariableAddress[#return] : +# 565| r565_2(int) = Constant[1] : +# 565| m565_3(int) = Store : &:r565_1, r565_2 +#-----| Goto -> Block 1 + +# 566| Block 3 +# 566| v566_1(void) = NoOp : +# 567| r567_1(glval) = VariableAddress[#return] : +# 567| r567_2(int) = Constant[-1] : +# 567| m567_3(int) = Store : &:r567_1, r567_2 +#-----| Goto -> Block 1 + +# 562| Block 4 +# 562| v562_1(void) = NoOp : +# 563| r563_1(glval) = VariableAddress[#return] : +# 563| r563_2(int) = Constant[0] : +# 563| m563_3(int) = Store : &:r563_1, r563_2 +#-----| Goto -> Block 1 + +# 571| void InitArray() +# 571| Block 0 +# 571| v571_1(void) = EnterFunction : +# 571| mu571_2(unknown) = AliasedDefinition : +# 571| mu571_3(unknown) = UnmodeledDefinition : +# 572| r572_1(glval) = VariableAddress[a_pad] : +# 572| r572_2(glval) = StringConstant[""] : +# 572| r572_3(char[32]) = Load : &:r572_2, ~mu571_3 +# 572| m572_4(char[32]) = Store : &:r572_1, r572_3 +# 573| r573_1(glval) = VariableAddress[a_nopad] : +# 573| r573_2(glval) = StringConstant["foo"] : +# 573| r573_3(char[4]) = Load : &:r573_2, ~mu571_3 +# 573| m573_4(char[4]) = Store : &:r573_1, r573_3 +# 574| r574_1(glval) = VariableAddress[a_infer] : +# 574| r574_2(glval) = StringConstant["blah"] : +# 574| r574_3(char[5]) = Load : &:r574_2, ~mu571_3 +# 574| m574_4(char[5]) = Store : &:r574_1, r574_3 +# 575| r575_1(glval) = VariableAddress[b] : +# 575| m575_2(char[2]) = Uninitialized[b] : &:r575_1 +# 576| r576_1(glval) = VariableAddress[c] : +# 576| mu576_2(char[2]) = Uninitialized[c] : &:r576_1 +# 576| r576_3(int) = Constant[0] : +# 576| r576_4(glval) = PointerAdd[1] : r576_1, r576_3 +# 576| r576_5(unknown[2]) = Constant[0] : +# 576| mu576_6(unknown[2]) = Store : &:r576_4, r576_5 +# 577| r577_1(glval) = VariableAddress[d] : +# 577| mu577_2(char[2]) = Uninitialized[d] : &:r577_1 +# 577| r577_3(int) = Constant[0] : +# 577| r577_4(glval) = PointerAdd[1] : r577_1, r577_3 +# 577| r577_5(char) = Constant[0] : +# 577| mu577_6(char) = Store : &:r577_4, r577_5 +# 577| r577_7(int) = Constant[1] : +# 577| r577_8(glval) = PointerAdd[1] : r577_1, r577_7 +# 577| r577_9(char) = Constant[0] : +# 577| mu577_10(char) = Store : &:r577_8, r577_9 +# 578| r578_1(glval) = VariableAddress[e] : +# 578| mu578_2(char[2]) = Uninitialized[e] : &:r578_1 +# 578| r578_3(int) = Constant[0] : +# 578| r578_4(glval) = PointerAdd[1] : r578_1, r578_3 +# 578| r578_5(char) = Constant[0] : +# 578| mu578_6(char) = Store : &:r578_4, r578_5 +# 578| r578_7(int) = Constant[1] : +# 578| r578_8(glval) = PointerAdd[1] : r578_1, r578_7 +# 578| r578_9(char) = Constant[1] : +# 578| mu578_10(char) = Store : &:r578_8, r578_9 +# 579| r579_1(glval) = VariableAddress[f] : +# 579| mu579_2(char[3]) = Uninitialized[f] : &:r579_1 +# 579| r579_3(int) = Constant[0] : +# 579| r579_4(glval) = PointerAdd[1] : r579_1, r579_3 +# 579| r579_5(char) = Constant[0] : +# 579| mu579_6(char) = Store : &:r579_4, r579_5 +# 579| r579_7(int) = Constant[1] : +# 579| r579_8(glval) = PointerAdd[1] : r579_1, r579_7 +# 579| r579_9(unknown[2]) = Constant[0] : +# 579| mu579_10(unknown[2]) = Store : &:r579_8, r579_9 +# 580| v580_1(void) = NoOp : +# 571| v571_4(void) = ReturnVoid : +# 571| v571_5(void) = UnmodeledUse : mu* +# 571| v571_6(void) = AliasedUse : ~mu571_3 +# 571| v571_7(void) = ExitFunction : + +# 584| void VarArgs() +# 584| Block 0 +# 584| v584_1(void) = EnterFunction : +# 584| mu584_2(unknown) = AliasedDefinition : +# 584| mu584_3(unknown) = UnmodeledDefinition : +# 585| r585_1(glval) = FunctionAddress[VarArgFunction] : +# 585| r585_2(glval) = StringConstant["%d %s"] : +# 585| r585_3(char *) = Convert : r585_2 +# 585| r585_4(int) = Constant[1] : +# 585| r585_5(glval) = StringConstant["string"] : +# 585| r585_6(char *) = Convert : r585_5 +# 585| v585_7(void) = Call : func:r585_1, 0:r585_3, 1:r585_4, 2:r585_6 +# 585| mu585_8(unknown) = ^CallSideEffect : ~mu584_3 +# 585| v585_9(void) = ^BufferReadSideEffect[0] : &:r585_3, ~mu584_3 +# 585| v585_10(void) = ^BufferReadSideEffect[2] : &:r585_6, ~mu584_3 +# 585| mu585_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r585_3 +# 585| mu585_12(unknown) = ^BufferMayWriteSideEffect[2] : &:r585_6 +# 586| v586_1(void) = NoOp : +# 584| v584_4(void) = ReturnVoid : +# 584| v584_5(void) = UnmodeledUse : mu* +# 584| v584_6(void) = AliasedUse : ~mu584_3 +# 584| v584_7(void) = ExitFunction : + +# 590| void SetFuncPtr() +# 590| Block 0 +# 590| v590_1(void) = EnterFunction : +# 590| mu590_2(unknown) = AliasedDefinition : +# 590| mu590_3(unknown) = UnmodeledDefinition : +# 591| r591_1(glval<..(*)(..)>) = VariableAddress[pfn] : +# 591| r591_2(..(*)(..)) = FunctionAddress[FuncPtrTarget] : +# 591| m591_3(..(*)(..)) = Store : &:r591_1, r591_2 +# 592| r592_1(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 592| r592_2(..(*)(..)) = CopyValue : r592_1 +# 592| r592_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 592| m592_4(..(*)(..)) = Store : &:r592_3, r592_2 +# 593| r593_1(..(*)(..)) = FunctionAddress[FuncPtrTarget] : +# 593| r593_2(..(*)(..)) = CopyValue : r593_1 +# 593| r593_3(glval<..(*)(..)>) = VariableAddress[pfn] : +# 593| m593_4(..(*)(..)) = Store : &:r593_3, r593_2 +# 594| r594_1(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 594| r594_2(..(*)(..)) = CopyValue : r594_1 +# 594| r594_3(..(*)(..)) = CopyValue : r594_2 +# 594| r594_4(..(*)(..)) = CopyValue : r594_3 +# 594| r594_5(..(*)(..)) = CopyValue : r594_4 +# 594| r594_6(glval<..(*)(..)>) = VariableAddress[pfn] : +# 594| m594_7(..(*)(..)) = Store : &:r594_6, r594_5 +# 595| v595_1(void) = NoOp : +# 590| v590_4(void) = ReturnVoid : +# 590| v590_5(void) = UnmodeledUse : mu* +# 590| v590_6(void) = AliasedUse : ~mu590_3 +# 590| v590_7(void) = ExitFunction : + +# 615| void DeclareObject() +# 615| Block 0 +# 615| v615_1(void) = EnterFunction : +# 615| mu615_2(unknown) = AliasedDefinition : +# 615| mu615_3(unknown) = UnmodeledDefinition : +# 616| r616_1(glval) = VariableAddress[s1] : +# 616| m616_2(String) = Uninitialized[s1] : &:r616_1 +# 616| r616_3(glval) = FunctionAddress[String] : +# 616| v616_4(void) = Call : func:r616_3, this:r616_1 +# 616| mu616_5(unknown) = ^CallSideEffect : ~mu615_3 +# 616| m616_6(String) = ^IndirectMayWriteSideEffect[-1] : &:r616_1 +# 617| r617_1(glval) = VariableAddress[s2] : +# 617| m617_2(String) = Uninitialized[s2] : &:r617_1 +# 617| r617_3(glval) = FunctionAddress[String] : +# 617| r617_4(glval) = StringConstant["hello"] : +# 617| r617_5(char *) = Convert : r617_4 +# 617| v617_6(void) = Call : func:r617_3, this:r617_1, 0:r617_5 +# 617| mu617_7(unknown) = ^CallSideEffect : ~mu615_3 +# 617| m617_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r617_1 +# 617| v617_9(void) = ^BufferReadSideEffect[0] : &:r617_5, ~mu615_3 +# 617| mu617_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r617_5 +# 618| r618_1(glval) = VariableAddress[s3] : +# 618| r618_2(glval) = FunctionAddress[ReturnObject] : +# 618| r618_3(String) = Call : func:r618_2 +# 618| mu618_4(unknown) = ^CallSideEffect : ~mu615_3 +# 618| m618_5(String) = Store : &:r618_1, r618_3 +# 619| r619_1(glval) = VariableAddress[s4] : +# 619| m619_2(String) = Uninitialized[s4] : &:r619_1 +# 619| r619_3(glval) = FunctionAddress[String] : +# 619| r619_4(glval) = StringConstant["test"] : +# 619| r619_5(char *) = Convert : r619_4 +# 619| v619_6(void) = Call : func:r619_3, this:r619_1, 0:r619_5 +# 619| mu619_7(unknown) = ^CallSideEffect : ~mu615_3 +# 619| m619_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r619_1 +# 619| v619_9(void) = ^BufferReadSideEffect[0] : &:r619_5, ~mu615_3 +# 619| mu619_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r619_5 +# 620| v620_1(void) = NoOp : +# 615| v615_4(void) = ReturnVoid : +# 615| v615_5(void) = UnmodeledUse : mu* +# 615| v615_6(void) = AliasedUse : ~mu615_3 +# 615| v615_7(void) = ExitFunction : + +# 622| void CallMethods(String&, String*, String) +# 622| Block 0 +# 622| v622_1(void) = EnterFunction : +# 622| mu622_2(unknown) = AliasedDefinition : +# 622| mu622_3(unknown) = UnmodeledDefinition : +# 622| r622_4(glval) = VariableAddress[r] : +# 622| m622_5(String &) = InitializeParameter[r] : &:r622_4 +# 622| r622_6(String &) = Load : &:r622_4, m622_5 +# 622| mu622_7(unknown) = InitializeIndirection[r] : &:r622_6 +# 622| r622_8(glval) = VariableAddress[p] : +# 622| m622_9(String *) = InitializeParameter[p] : &:r622_8 +# 622| r622_10(String *) = Load : &:r622_8, m622_9 +# 622| mu622_11(unknown) = InitializeIndirection[p] : &:r622_10 +# 622| r622_12(glval) = VariableAddress[s] : +# 622| mu622_13(String) = InitializeParameter[s] : &:r622_12 +# 623| r623_1(glval) = VariableAddress[r] : +# 623| r623_2(String &) = Load : &:r623_1, m622_5 +# 623| r623_3(glval) = CopyValue : r623_2 +# 623| r623_4(glval) = Convert : r623_3 +# 623| r623_5(glval) = FunctionAddress[c_str] : +# 623| r623_6(char *) = Call : func:r623_5, this:r623_4 +# 623| mu623_7(unknown) = ^CallSideEffect : ~mu622_3 +# 623| v623_8(void) = ^BufferReadSideEffect[-1] : &:r623_4, ~mu622_3 +# 623| mu623_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r623_4 +# 624| r624_1(glval) = VariableAddress[p] : +# 624| r624_2(String *) = Load : &:r624_1, m622_9 +# 624| r624_3(String *) = Convert : r624_2 +# 624| r624_4(glval) = FunctionAddress[c_str] : +# 624| r624_5(char *) = Call : func:r624_4, this:r624_3 +# 624| mu624_6(unknown) = ^CallSideEffect : ~mu622_3 +# 624| v624_7(void) = ^BufferReadSideEffect[-1] : &:r624_3, ~mu622_3 +# 624| mu624_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r624_3 +# 625| r625_1(glval) = VariableAddress[s] : +# 625| r625_2(glval) = Convert : r625_1 +# 625| r625_3(glval) = FunctionAddress[c_str] : +# 625| r625_4(char *) = Call : func:r625_3, this:r625_2 +# 625| mu625_5(unknown) = ^CallSideEffect : ~mu622_3 +# 625| v625_6(void) = ^BufferReadSideEffect[-1] : &:r625_2, ~mu622_3 +# 625| mu625_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r625_2 +# 626| v626_1(void) = NoOp : +# 622| v622_14(void) = ReturnIndirection : &:r622_6, ~mu622_3 +# 622| v622_15(void) = ReturnIndirection : &:r622_10, ~mu622_3 +# 622| v622_16(void) = ReturnVoid : +# 622| v622_17(void) = UnmodeledUse : mu* +# 622| v622_18(void) = AliasedUse : ~mu622_3 +# 622| v622_19(void) = ExitFunction : + +# 630| int C::StaticMemberFunction(int) +# 630| Block 0 +# 630| v630_1(void) = EnterFunction : +# 630| mu630_2(unknown) = AliasedDefinition : +# 630| mu630_3(unknown) = UnmodeledDefinition : +# 630| r630_4(glval) = VariableAddress[x] : +# 630| m630_5(int) = InitializeParameter[x] : &:r630_4 +# 631| r631_1(glval) = VariableAddress[#return] : +# 631| r631_2(glval) = VariableAddress[x] : +# 631| r631_3(int) = Load : &:r631_2, m630_5 +# 631| m631_4(int) = Store : &:r631_1, r631_3 +# 630| r630_6(glval) = VariableAddress[#return] : +# 630| v630_7(void) = ReturnValue : &:r630_6, m631_4 +# 630| v630_8(void) = UnmodeledUse : mu* +# 630| v630_9(void) = AliasedUse : ~mu630_3 +# 630| v630_10(void) = ExitFunction : + +# 634| int C::InstanceMemberFunction(int) +# 634| Block 0 +# 634| v634_1(void) = EnterFunction : +# 634| mu634_2(unknown) = AliasedDefinition : +# 634| mu634_3(unknown) = UnmodeledDefinition : +# 634| r634_4(glval) = InitializeThis : +# 634| r634_5(glval) = VariableAddress[x] : +# 634| m634_6(int) = InitializeParameter[x] : &:r634_5 +# 635| r635_1(glval) = VariableAddress[#return] : +# 635| r635_2(glval) = VariableAddress[x] : +# 635| r635_3(int) = Load : &:r635_2, m634_6 +# 635| m635_4(int) = Store : &:r635_1, r635_3 +# 634| r634_7(glval) = VariableAddress[#return] : +# 634| v634_8(void) = ReturnValue : &:r634_7, m635_4 +# 634| v634_9(void) = UnmodeledUse : mu* +# 634| v634_10(void) = AliasedUse : ~mu634_3 +# 634| v634_11(void) = ExitFunction : + +# 638| int C::VirtualMemberFunction(int) +# 638| Block 0 +# 638| v638_1(void) = EnterFunction : +# 638| mu638_2(unknown) = AliasedDefinition : +# 638| mu638_3(unknown) = UnmodeledDefinition : +# 638| r638_4(glval) = InitializeThis : +# 638| r638_5(glval) = VariableAddress[x] : +# 638| m638_6(int) = InitializeParameter[x] : &:r638_5 +# 639| r639_1(glval) = VariableAddress[#return] : +# 639| r639_2(glval) = VariableAddress[x] : +# 639| r639_3(int) = Load : &:r639_2, m638_6 +# 639| m639_4(int) = Store : &:r639_1, r639_3 +# 638| r638_7(glval) = VariableAddress[#return] : +# 638| v638_8(void) = ReturnValue : &:r638_7, m639_4 +# 638| v638_9(void) = UnmodeledUse : mu* +# 638| v638_10(void) = AliasedUse : ~mu638_3 +# 638| v638_11(void) = ExitFunction : + +# 642| void C::FieldAccess() +# 642| Block 0 +# 642| v642_1(void) = EnterFunction : +# 642| mu642_2(unknown) = AliasedDefinition : +# 642| mu642_3(unknown) = UnmodeledDefinition : +# 642| r642_4(glval) = InitializeThis : +# 643| r643_1(int) = Constant[0] : +# 643| r643_2(C *) = CopyValue : r642_4 +# 643| r643_3(glval) = FieldAddress[m_a] : r643_2 +# 643| mu643_4(int) = Store : &:r643_3, r643_1 +# 644| r644_1(int) = Constant[1] : +# 644| r644_2(C *) = CopyValue : r642_4 +# 644| r644_3(glval) = CopyValue : r644_2 +# 644| r644_4(glval) = FieldAddress[m_a] : r644_3 +# 644| mu644_5(int) = Store : &:r644_4, r644_1 +# 645| r645_1(int) = Constant[2] : +#-----| r0_1(C *) = CopyValue : r642_4 +# 645| r645_2(glval) = FieldAddress[m_a] : r0_1 +# 645| mu645_3(int) = Store : &:r645_2, r645_1 +# 646| r646_1(glval) = VariableAddress[x] : +# 646| m646_2(int) = Uninitialized[x] : &:r646_1 +# 647| r647_1(C *) = CopyValue : r642_4 +# 647| r647_2(glval) = FieldAddress[m_a] : r647_1 +# 647| r647_3(int) = Load : &:r647_2, ~mu642_3 +# 647| r647_4(glval) = VariableAddress[x] : +# 647| m647_5(int) = Store : &:r647_4, r647_3 +# 648| r648_1(C *) = CopyValue : r642_4 +# 648| r648_2(glval) = CopyValue : r648_1 +# 648| r648_3(glval) = FieldAddress[m_a] : r648_2 +# 648| r648_4(int) = Load : &:r648_3, ~mu642_3 +# 648| r648_5(glval) = VariableAddress[x] : +# 648| m648_6(int) = Store : &:r648_5, r648_4 +#-----| r0_2(C *) = CopyValue : r642_4 +# 649| r649_1(glval) = FieldAddress[m_a] : r0_2 +# 649| r649_2(int) = Load : &:r649_1, ~mu642_3 +# 649| r649_3(glval) = VariableAddress[x] : +# 649| m649_4(int) = Store : &:r649_3, r649_2 +# 650| v650_1(void) = NoOp : +# 642| v642_5(void) = ReturnVoid : +# 642| v642_6(void) = UnmodeledUse : mu* +# 642| v642_7(void) = AliasedUse : ~mu642_3 +# 642| v642_8(void) = ExitFunction : + +# 652| void C::MethodCalls() +# 652| Block 0 +# 652| v652_1(void) = EnterFunction : +# 652| mu652_2(unknown) = AliasedDefinition : +# 652| mu652_3(unknown) = UnmodeledDefinition : +# 652| r652_4(glval) = InitializeThis : +# 653| r653_1(C *) = CopyValue : r652_4 +# 653| r653_2(glval) = FunctionAddress[InstanceMemberFunction] : +# 653| r653_3(int) = Constant[0] : +# 653| r653_4(int) = Call : func:r653_2, this:r653_1, 0:r653_3 +# 653| mu653_5(unknown) = ^CallSideEffect : ~mu652_3 +# 653| v653_6(void) = ^BufferReadSideEffect[-1] : &:r653_1, ~mu652_3 +# 653| mu653_7(C) = ^IndirectMayWriteSideEffect[-1] : &:r653_1 +# 654| r654_1(C *) = CopyValue : r652_4 +# 654| r654_2(glval) = CopyValue : r654_1 +# 654| r654_3(glval) = FunctionAddress[InstanceMemberFunction] : +# 654| r654_4(int) = Constant[1] : +# 654| r654_5(int) = Call : func:r654_3, this:r654_2, 0:r654_4 +# 654| mu654_6(unknown) = ^CallSideEffect : ~mu652_3 +# 654| v654_7(void) = ^BufferReadSideEffect[-1] : &:r654_2, ~mu652_3 +# 654| mu654_8(C) = ^IndirectMayWriteSideEffect[-1] : &:r654_2 +#-----| r0_1(C *) = CopyValue : r652_4 +# 655| r655_1(glval) = FunctionAddress[InstanceMemberFunction] : +# 655| r655_2(int) = Constant[2] : +# 655| r655_3(int) = Call : func:r655_1, this:r0_1, 0:r655_2 +# 655| mu655_4(unknown) = ^CallSideEffect : ~mu652_3 +#-----| v0_2(void) = ^BufferReadSideEffect[-1] : &:r0_1, ~mu652_3 +#-----| mu0_3(C) = ^IndirectMayWriteSideEffect[-1] : &:r0_1 +# 656| v656_1(void) = NoOp : +# 652| v652_5(void) = ReturnVoid : +# 652| v652_6(void) = UnmodeledUse : mu* +# 652| v652_7(void) = AliasedUse : ~mu652_3 +# 652| v652_8(void) = ExitFunction : + +# 658| void C::C() +# 658| Block 0 +# 658| v658_1(void) = EnterFunction : +# 658| mu658_2(unknown) = AliasedDefinition : +# 658| mu658_3(unknown) = UnmodeledDefinition : +# 658| r658_4(glval) = InitializeThis : +# 659| r659_1(glval) = FieldAddress[m_a] : r658_4 +# 659| r659_2(int) = Constant[1] : +# 659| mu659_3(int) = Store : &:r659_1, r659_2 +# 663| r663_1(glval) = FieldAddress[m_b] : r658_4 +# 663| r663_2(glval) = FunctionAddress[String] : +# 663| v663_3(void) = Call : func:r663_2, this:r663_1 +# 663| mu663_4(unknown) = ^CallSideEffect : ~mu658_3 +# 663| mu663_5(String) = ^IndirectMayWriteSideEffect[-1] : &:r663_1 +# 660| r660_1(glval) = FieldAddress[m_c] : r658_4 +# 660| r660_2(char) = Constant[3] : +# 660| mu660_3(char) = Store : &:r660_1, r660_2 +# 661| r661_1(glval) = FieldAddress[m_e] : r658_4 +# 661| r661_2(void *) = Constant[0] : +# 661| mu661_3(void *) = Store : &:r661_1, r661_2 +# 662| r662_1(glval) = FieldAddress[m_f] : r658_4 +# 662| r662_2(glval) = FunctionAddress[String] : +# 662| r662_3(glval) = StringConstant["test"] : +# 662| r662_4(char *) = Convert : r662_3 +# 662| v662_5(void) = Call : func:r662_2, this:r662_1, 0:r662_4 +# 662| mu662_6(unknown) = ^CallSideEffect : ~mu658_3 +# 662| mu662_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r662_1 +# 662| v662_8(void) = ^BufferReadSideEffect[0] : &:r662_4, ~mu658_3 +# 662| mu662_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r662_4 +# 664| v664_1(void) = NoOp : +# 658| v658_5(void) = ReturnVoid : +# 658| v658_6(void) = UnmodeledUse : mu* +# 658| v658_7(void) = AliasedUse : ~mu658_3 +# 658| v658_8(void) = ExitFunction : + +# 675| int DerefReference(int&) +# 675| Block 0 +# 675| v675_1(void) = EnterFunction : +# 675| mu675_2(unknown) = AliasedDefinition : +# 675| mu675_3(unknown) = UnmodeledDefinition : +# 675| r675_4(glval) = VariableAddress[r] : +# 675| m675_5(int &) = InitializeParameter[r] : &:r675_4 +# 675| r675_6(int &) = Load : &:r675_4, m675_5 +# 675| mu675_7(unknown) = InitializeIndirection[r] : &:r675_6 +# 676| r676_1(glval) = VariableAddress[#return] : +# 676| r676_2(glval) = VariableAddress[r] : +# 676| r676_3(int &) = Load : &:r676_2, m675_5 +# 676| r676_4(int) = Load : &:r676_3, ~mu675_3 +# 676| m676_5(int) = Store : &:r676_1, r676_4 +# 675| v675_8(void) = ReturnIndirection : &:r675_6, ~mu675_3 +# 675| r675_9(glval) = VariableAddress[#return] : +# 675| v675_10(void) = ReturnValue : &:r675_9, m676_5 +# 675| v675_11(void) = UnmodeledUse : mu* +# 675| v675_12(void) = AliasedUse : ~mu675_3 +# 675| v675_13(void) = ExitFunction : + +# 679| int& TakeReference() +# 679| Block 0 +# 679| v679_1(void) = EnterFunction : +# 679| mu679_2(unknown) = AliasedDefinition : +# 679| mu679_3(unknown) = UnmodeledDefinition : +# 680| r680_1(glval) = VariableAddress[#return] : +# 680| r680_2(glval) = VariableAddress[g] : +# 680| r680_3(int &) = CopyValue : r680_2 +# 680| m680_4(int &) = Store : &:r680_1, r680_3 +# 679| r679_4(glval) = VariableAddress[#return] : +# 679| v679_5(void) = ReturnValue : &:r679_4, m680_4 +# 679| v679_6(void) = UnmodeledUse : mu* +# 679| v679_7(void) = AliasedUse : ~mu679_3 +# 679| v679_8(void) = ExitFunction : + +# 685| void InitReference(int) +# 685| Block 0 +# 685| v685_1(void) = EnterFunction : +# 685| mu685_2(unknown) = AliasedDefinition : +# 685| mu685_3(unknown) = UnmodeledDefinition : +# 685| r685_4(glval) = VariableAddress[x] : +# 685| m685_5(int) = InitializeParameter[x] : &:r685_4 +# 686| r686_1(glval) = VariableAddress[r] : +# 686| r686_2(glval) = VariableAddress[x] : +# 686| r686_3(int &) = CopyValue : r686_2 +# 686| m686_4(int &) = Store : &:r686_1, r686_3 +# 687| r687_1(glval) = VariableAddress[r2] : +# 687| r687_2(glval) = VariableAddress[r] : +# 687| r687_3(int &) = Load : &:r687_2, m686_4 +# 687| r687_4(glval) = CopyValue : r687_3 +# 687| r687_5(int &) = CopyValue : r687_4 +# 687| m687_6(int &) = Store : &:r687_1, r687_5 +# 688| r688_1(glval) = VariableAddress[r3] : +# 688| r688_2(glval) = FunctionAddress[ReturnReference] : +# 688| r688_3(String &) = Call : func:r688_2 +# 688| mu688_4(unknown) = ^CallSideEffect : ~mu685_3 +# 688| r688_5(glval) = CopyValue : r688_3 +# 688| r688_6(glval) = Convert : r688_5 +# 688| r688_7(String &) = CopyValue : r688_6 +# 688| m688_8(String &) = Store : &:r688_1, r688_7 +# 689| v689_1(void) = NoOp : +# 685| v685_6(void) = ReturnVoid : +# 685| v685_7(void) = UnmodeledUse : mu* +# 685| v685_8(void) = AliasedUse : ~mu685_3 +# 685| v685_9(void) = ExitFunction : + +# 691| void ArrayReferences() +# 691| Block 0 +# 691| v691_1(void) = EnterFunction : +# 691| mu691_2(unknown) = AliasedDefinition : +# 691| mu691_3(unknown) = UnmodeledDefinition : +# 692| r692_1(glval) = VariableAddress[a] : +# 692| m692_2(int[10]) = Uninitialized[a] : &:r692_1 +# 693| r693_1(glval) = VariableAddress[ra] : +# 693| r693_2(glval) = VariableAddress[a] : +# 693| r693_3(int(&)[10]) = CopyValue : r693_2 +# 693| m693_4(int(&)[10]) = Store : &:r693_1, r693_3 +# 694| r694_1(glval) = VariableAddress[x] : +# 694| r694_2(glval) = VariableAddress[ra] : +# 694| r694_3(int(&)[10]) = Load : &:r694_2, m693_4 +# 694| r694_4(glval) = CopyValue : r694_3 +# 694| r694_5(int *) = Convert : r694_4 +# 694| r694_6(int) = Constant[5] : +# 694| r694_7(glval) = PointerAdd[4] : r694_5, r694_6 +# 694| r694_8(int) = Load : &:r694_7, ~mu691_3 +# 694| m694_9(int) = Store : &:r694_1, r694_8 +# 695| v695_1(void) = NoOp : +# 691| v691_4(void) = ReturnVoid : +# 691| v691_5(void) = UnmodeledUse : mu* +# 691| v691_6(void) = AliasedUse : ~mu691_3 +# 691| v691_7(void) = ExitFunction : + +# 697| void FunctionReferences() +# 697| Block 0 +# 697| v697_1(void) = EnterFunction : +# 697| mu697_2(unknown) = AliasedDefinition : +# 697| mu697_3(unknown) = UnmodeledDefinition : +# 698| r698_1(glval<..(&)(..)>) = VariableAddress[rfn] : +# 698| r698_2(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : +# 698| r698_3(..(&)(..)) = CopyValue : r698_2 +# 698| m698_4(..(&)(..)) = Store : &:r698_1, r698_3 +# 699| r699_1(glval<..(*)(..)>) = VariableAddress[pfn] : +# 699| r699_2(glval<..(&)(..)>) = VariableAddress[rfn] : +# 699| r699_3(..(&)(..)) = Load : &:r699_2, m698_4 +# 699| r699_4(..(*)(..)) = CopyValue : r699_3 +# 699| m699_5(..(*)(..)) = Store : &:r699_1, r699_4 +# 700| r700_1(glval<..(&)(..)>) = VariableAddress[rfn] : +# 700| r700_2(..(&)(..)) = Load : &:r700_1, m698_4 +# 700| r700_3(..(*)(..)) = CopyValue : r700_2 +# 700| r700_4(int) = Constant[5] : +# 700| r700_5(int) = Call : func:r700_3, 0:r700_4 +# 700| mu700_6(unknown) = ^CallSideEffect : ~mu697_3 +# 701| v701_1(void) = NoOp : +# 697| v697_4(void) = ReturnVoid : +# 697| v697_5(void) = UnmodeledUse : mu* +# 697| v697_6(void) = AliasedUse : ~mu697_3 +# 697| v697_7(void) = ExitFunction : + +# 704| int min(int, int) +# 704| Block 0 +# 704| v704_1(void) = EnterFunction : +# 704| mu704_2(unknown) = AliasedDefinition : +# 704| mu704_3(unknown) = UnmodeledDefinition : +# 704| r704_4(glval) = VariableAddress[x] : +# 704| m704_5(int) = InitializeParameter[x] : &:r704_4 +# 704| r704_6(glval) = VariableAddress[y] : +# 704| m704_7(int) = InitializeParameter[y] : &:r704_6 +# 705| r705_1(glval) = VariableAddress[#return] : +# 705| r705_2(glval) = VariableAddress[x] : +# 705| r705_3(int) = Load : &:r705_2, m704_5 +# 705| r705_4(glval) = VariableAddress[y] : +# 705| r705_5(int) = Load : &:r705_4, m704_7 +# 705| r705_6(bool) = CompareLT : r705_3, r705_5 +# 705| v705_7(void) = ConditionalBranch : r705_6 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 705| Block 1 +# 705| r705_8(glval) = VariableAddress[x] : +# 705| r705_9(int) = Load : &:r705_8, m704_5 +# 705| r705_10(glval) = VariableAddress[#temp705:10] : +# 705| m705_11(int) = Store : &:r705_10, r705_9 +#-----| Goto -> Block 3 + +# 705| Block 2 +# 705| r705_12(glval) = VariableAddress[y] : +# 705| r705_13(int) = Load : &:r705_12, m704_7 +# 705| r705_14(glval) = VariableAddress[#temp705:10] : +# 705| m705_15(int) = Store : &:r705_14, r705_13 +#-----| Goto -> Block 3 + +# 705| Block 3 +# 705| m705_16(int) = Phi : from 1:m705_11, from 2:m705_15 +# 705| r705_17(glval) = VariableAddress[#temp705:10] : +# 705| r705_18(int) = Load : &:r705_17, m705_16 +# 705| m705_19(int) = Store : &:r705_1, r705_18 +# 704| r704_8(glval) = VariableAddress[#return] : +# 704| v704_9(void) = ReturnValue : &:r704_8, m705_19 +# 704| v704_10(void) = UnmodeledUse : mu* +# 704| v704_11(void) = AliasedUse : ~mu704_3 +# 704| v704_12(void) = ExitFunction : + +# 708| int CallMin(int, int) +# 708| Block 0 +# 708| v708_1(void) = EnterFunction : +# 708| mu708_2(unknown) = AliasedDefinition : +# 708| mu708_3(unknown) = UnmodeledDefinition : +# 708| r708_4(glval) = VariableAddress[x] : +# 708| m708_5(int) = InitializeParameter[x] : &:r708_4 +# 708| r708_6(glval) = VariableAddress[y] : +# 708| m708_7(int) = InitializeParameter[y] : &:r708_6 +# 709| r709_1(glval) = VariableAddress[#return] : +# 709| r709_2(glval) = FunctionAddress[min] : +# 709| r709_3(glval) = VariableAddress[x] : +# 709| r709_4(int) = Load : &:r709_3, m708_5 +# 709| r709_5(glval) = VariableAddress[y] : +# 709| r709_6(int) = Load : &:r709_5, m708_7 +# 709| r709_7(int) = Call : func:r709_2, 0:r709_4, 1:r709_6 +# 709| mu709_8(unknown) = ^CallSideEffect : ~mu708_3 +# 709| m709_9(int) = Store : &:r709_1, r709_7 +# 708| r708_8(glval) = VariableAddress[#return] : +# 708| v708_9(void) = ReturnValue : &:r708_8, m709_9 +# 708| v708_10(void) = UnmodeledUse : mu* +# 708| v708_11(void) = AliasedUse : ~mu708_3 +# 708| v708_12(void) = ExitFunction : + +# 715| long Outer::Func(void*, char) +# 715| Block 0 +# 715| v715_1(void) = EnterFunction : +# 715| mu715_2(unknown) = AliasedDefinition : +# 715| mu715_3(unknown) = UnmodeledDefinition : +# 715| r715_4(glval) = VariableAddress[x] : +# 715| m715_5(void *) = InitializeParameter[x] : &:r715_4 +# 715| r715_6(void *) = Load : &:r715_4, m715_5 +# 715| mu715_7(unknown) = InitializeIndirection[x] : &:r715_6 +# 715| r715_8(glval) = VariableAddress[y] : +# 715| m715_9(char) = InitializeParameter[y] : &:r715_8 +# 716| r716_1(glval) = VariableAddress[#return] : +# 716| r716_2(long) = Constant[0] : +# 716| m716_3(long) = Store : &:r716_1, r716_2 +# 715| v715_10(void) = ReturnIndirection : &:r715_6, ~mu715_3 +# 715| r715_11(glval) = VariableAddress[#return] : +# 715| v715_12(void) = ReturnValue : &:r715_11, m716_3 +# 715| v715_13(void) = UnmodeledUse : mu* +# 715| v715_14(void) = AliasedUse : ~mu715_3 +# 715| v715_15(void) = ExitFunction : + +# 720| double CallNestedTemplateFunc() +# 720| Block 0 +# 720| v720_1(void) = EnterFunction : +# 720| mu720_2(unknown) = AliasedDefinition : +# 720| mu720_3(unknown) = UnmodeledDefinition : +# 721| r721_1(glval) = VariableAddress[#return] : +# 721| r721_2(glval) = FunctionAddress[Func] : +# 721| r721_3(void *) = Constant[0] : +# 721| r721_4(char) = Constant[111] : +# 721| r721_5(long) = Call : func:r721_2, 0:r721_3, 1:r721_4 +# 721| mu721_6(unknown) = ^CallSideEffect : ~mu720_3 +# 721| v721_7(void) = ^BufferReadSideEffect[0] : &:r721_3, ~mu720_3 +# 721| mu721_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r721_3 +# 721| r721_9(double) = Convert : r721_5 +# 721| m721_10(double) = Store : &:r721_1, r721_9 +# 720| r720_4(glval) = VariableAddress[#return] : +# 720| v720_5(void) = ReturnValue : &:r720_4, m721_10 +# 720| v720_6(void) = UnmodeledUse : mu* +# 720| v720_7(void) = AliasedUse : ~mu720_3 +# 720| v720_8(void) = ExitFunction : + +# 724| void TryCatch(bool) +# 724| Block 0 +# 724| v724_1(void) = EnterFunction : +# 724| mu724_2(unknown) = AliasedDefinition : +# 724| mu724_3(unknown) = UnmodeledDefinition : +# 724| r724_4(glval) = VariableAddress[b] : +# 724| m724_5(bool) = InitializeParameter[b] : &:r724_4 +# 726| r726_1(glval) = VariableAddress[x] : +# 726| r726_2(int) = Constant[5] : +# 726| m726_3(int) = Store : &:r726_1, r726_2 +# 727| r727_1(glval) = VariableAddress[b] : +# 727| r727_2(bool) = Load : &:r727_1, m724_5 +# 727| v727_3(void) = ConditionalBranch : r727_2 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 724| Block 1 +# 724| v724_6(void) = UnmodeledUse : mu* +# 724| v724_7(void) = AliasedUse : ~mu724_3 +# 724| v724_8(void) = ExitFunction : + +# 724| Block 2 +# 724| v724_9(void) = Unwind : +#-----| Goto -> Block 1 + +# 728| Block 3 +# 728| r728_1(glval) = VariableAddress[#throw728:7] : +# 728| r728_2(glval) = StringConstant["string literal"] : +# 728| r728_3(char *) = Convert : r728_2 +# 728| m728_4(char *) = Store : &:r728_1, r728_3 +# 728| v728_5(void) = ThrowValue : &:r728_1, m728_4 +#-----| Exception -> Block 9 + +# 730| Block 4 +# 730| r730_1(glval) = VariableAddress[x] : +# 730| r730_2(int) = Load : &:r730_1, m726_3 +# 730| r730_3(int) = Constant[2] : +# 730| r730_4(bool) = CompareLT : r730_2, r730_3 +# 730| v730_5(void) = ConditionalBranch : r730_4 +#-----| False -> Block 8 +#-----| True -> Block 5 + +# 731| Block 5 +# 731| r731_1(glval) = VariableAddress[b] : +# 731| r731_2(bool) = Load : &:r731_1, m724_5 +# 731| v731_3(void) = ConditionalBranch : r731_2 +#-----| False -> Block 7 +#-----| True -> Block 6 + +# 731| Block 6 +# 731| r731_4(int) = Constant[7] : +# 731| r731_5(glval) = VariableAddress[#temp731:11] : +# 731| m731_6(int) = Store : &:r731_5, r731_4 +# 731| r731_7(glval) = VariableAddress[#temp731:11] : +# 731| r731_8(int) = Load : &:r731_7, m731_6 +# 731| r731_9(glval) = VariableAddress[x] : +# 731| m731_10(int) = Store : &:r731_9, r731_8 +#-----| Goto -> Block 8 + +# 731| Block 7 +# 731| r731_11(glval) = VariableAddress[#throw731:19] : +# 731| m731_12(String) = Uninitialized[#throw731:19] : &:r731_11 +# 731| r731_13(glval) = FunctionAddress[String] : +# 731| r731_14(glval) = StringConstant["String object"] : +# 731| r731_15(char *) = Convert : r731_14 +# 731| v731_16(void) = Call : func:r731_13, this:r731_11, 0:r731_15 +# 731| mu731_17(unknown) = ^CallSideEffect : ~mu724_3 +# 731| m731_18(String) = ^IndirectMayWriteSideEffect[-1] : &:r731_11 +# 731| v731_19(void) = ^BufferReadSideEffect[0] : &:r731_15, ~mu724_3 +# 731| mu731_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r731_15 +# 731| v731_21(void) = ThrowValue : &:r731_11, m731_18 +#-----| Exception -> Block 9 + +# 733| Block 8 +# 733| r733_1(int) = Constant[7] : +# 733| r733_2(glval) = VariableAddress[x] : +# 733| m733_3(int) = Store : &:r733_2, r733_1 +#-----| Goto -> Block 14 + +# 735| Block 9 +# 735| v735_1(void) = CatchByType[const char *] : +#-----| Exception -> Block 11 +#-----| Goto -> Block 10 + +# 735| Block 10 +# 735| r735_2(glval) = VariableAddress[s] : +# 735| m735_3(char *) = InitializeParameter[s] : &:r735_2 +# 735| r735_4(char *) = Load : &:r735_2, m735_3 +# 735| mu735_5(unknown) = InitializeIndirection[s] : &:r735_4 +# 736| r736_1(glval) = VariableAddress[#throw736:5] : +# 736| m736_2(String) = Uninitialized[#throw736:5] : &:r736_1 +# 736| r736_3(glval) = FunctionAddress[String] : +# 736| r736_4(glval) = VariableAddress[s] : +# 736| r736_5(char *) = Load : &:r736_4, m735_3 +# 736| v736_6(void) = Call : func:r736_3, this:r736_1, 0:r736_5 +# 736| mu736_7(unknown) = ^CallSideEffect : ~mu724_3 +# 736| m736_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r736_1 +# 736| v736_9(void) = ^BufferReadSideEffect[0] : &:r736_5, ~mu724_3 +# 736| mu736_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r736_5 +# 736| v736_11(void) = ThrowValue : &:r736_1, m736_8 +#-----| Exception -> Block 2 + +# 738| Block 11 +# 738| v738_1(void) = CatchByType[const String &] : +#-----| Exception -> Block 13 +#-----| Goto -> Block 12 + +# 738| Block 12 +# 738| r738_2(glval) = VariableAddress[e] : +# 738| m738_3(String &) = InitializeParameter[e] : &:r738_2 +# 738| r738_4(String &) = Load : &:r738_2, m738_3 +# 738| mu738_5(unknown) = InitializeIndirection[e] : &:r738_4 +# 738| v738_6(void) = NoOp : +#-----| Goto -> Block 14 + +# 740| Block 13 +# 740| v740_1(void) = CatchAny : +# 741| v741_1(void) = ReThrow : +#-----| Exception -> Block 2 + +# 743| Block 14 +# 743| v743_1(void) = NoOp : +# 724| v724_10(void) = ReturnVoid : +#-----| Goto -> Block 1 + +# 745| Base& Base::operator=(Base const&) +# 745| Block 0 +# 745| v745_1(void) = EnterFunction : +# 745| mu745_2(unknown) = AliasedDefinition : +# 745| mu745_3(unknown) = UnmodeledDefinition : +# 745| r745_4(glval) = InitializeThis : +#-----| r0_1(glval) = VariableAddress[p#0] : +#-----| m0_2(Base &) = InitializeParameter[p#0] : &:r0_1 +#-----| r0_3(Base &) = Load : &:r0_1, m0_2 +#-----| mu0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 +#-----| r0_5(Base *) = CopyValue : r745_4 +#-----| r0_6(glval) = FieldAddress[base_s] : r0_5 +#-----| r0_7(String *) = CopyValue : r0_6 +# 745| r745_5(glval) = FunctionAddress[operator=] : +#-----| r0_8(glval) = VariableAddress[p#0] : +#-----| r0_9(Base &) = Load : &:r0_8, m0_2 +#-----| r0_10(glval) = CopyValue : r0_9 +#-----| r0_11(glval) = FieldAddress[base_s] : r0_10 +#-----| r0_12(String &) = CopyValue : r0_11 +# 745| r745_6(String &) = Call : func:r745_5, this:r0_7, 0:r0_12 +# 745| mu745_7(unknown) = ^CallSideEffect : ~mu745_3 +#-----| v0_13(void) = ^BufferReadSideEffect[-1] : &:r0_7, ~mu745_3 +#-----| v0_14(void) = ^BufferReadSideEffect[0] : &:r0_12, ~mu745_3 +#-----| mu0_15(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_7 +#-----| mu0_16(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_12 +#-----| r0_17(glval) = CopyValue : r745_6 +#-----| r0_18(glval) = VariableAddress[#return] : +#-----| r0_19(Base *) = CopyValue : r745_4 +#-----| r0_20(glval) = CopyValue : r0_19 +#-----| r0_21(Base &) = CopyValue : r0_20 +#-----| m0_22(Base &) = Store : &:r0_18, r0_21 +#-----| v0_23(void) = ReturnIndirection : &:r0_3, ~mu745_3 +# 745| r745_8(glval) = VariableAddress[#return] : +# 745| v745_9(void) = ReturnValue : &:r745_8, m0_22 +# 745| v745_10(void) = UnmodeledUse : mu* +# 745| v745_11(void) = AliasedUse : ~mu745_3 +# 745| v745_12(void) = ExitFunction : + +# 745| void Base::Base(Base const&) +# 745| Block 0 +# 745| v745_1(void) = EnterFunction : +# 745| mu745_2(unknown) = AliasedDefinition : +# 745| mu745_3(unknown) = UnmodeledDefinition : +# 745| r745_4(glval) = InitializeThis : +#-----| r0_1(glval) = VariableAddress[p#0] : +#-----| m0_2(Base &) = InitializeParameter[p#0] : &:r0_1 +#-----| r0_3(Base &) = Load : &:r0_1, m0_2 +#-----| mu0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 +# 745| r745_5(glval) = FieldAddress[base_s] : r745_4 +# 745| r745_6(glval) = FunctionAddress[String] : +# 745| v745_7(void) = Call : func:r745_6, this:r745_5 +# 745| mu745_8(unknown) = ^CallSideEffect : ~mu745_3 +# 745| mu745_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r745_5 +# 745| v745_10(void) = NoOp : +#-----| v0_5(void) = ReturnIndirection : &:r0_3, ~mu745_3 +# 745| v745_11(void) = ReturnVoid : +# 745| v745_12(void) = UnmodeledUse : mu* +# 745| v745_13(void) = AliasedUse : ~mu745_3 +# 745| v745_14(void) = ExitFunction : + +# 748| void Base::Base() +# 748| Block 0 +# 748| v748_1(void) = EnterFunction : +# 748| mu748_2(unknown) = AliasedDefinition : +# 748| mu748_3(unknown) = UnmodeledDefinition : +# 748| r748_4(glval) = InitializeThis : +# 748| r748_5(glval) = FieldAddress[base_s] : r748_4 +# 748| r748_6(glval) = FunctionAddress[String] : +# 748| v748_7(void) = Call : func:r748_6, this:r748_5 +# 748| mu748_8(unknown) = ^CallSideEffect : ~mu748_3 +# 748| mu748_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r748_5 +# 749| v749_1(void) = NoOp : +# 748| v748_10(void) = ReturnVoid : +# 748| v748_11(void) = UnmodeledUse : mu* +# 748| v748_12(void) = AliasedUse : ~mu748_3 +# 748| v748_13(void) = ExitFunction : + +# 750| void Base::~Base() +# 750| Block 0 +# 750| v750_1(void) = EnterFunction : +# 750| mu750_2(unknown) = AliasedDefinition : +# 750| mu750_3(unknown) = UnmodeledDefinition : +# 750| r750_4(glval) = InitializeThis : +# 751| v751_1(void) = NoOp : +# 751| r751_2(glval) = FieldAddress[base_s] : r750_4 +# 751| r751_3(glval) = FunctionAddress[~String] : +# 751| v751_4(void) = Call : func:r751_3, this:r751_2 +# 751| mu751_5(unknown) = ^CallSideEffect : ~mu750_3 +# 750| v750_5(void) = ReturnVoid : +# 750| v750_6(void) = UnmodeledUse : mu* +# 750| v750_7(void) = AliasedUse : ~mu750_3 +# 750| v750_8(void) = ExitFunction : + +# 754| Middle& Middle::operator=(Middle const&) +# 754| Block 0 +# 754| v754_1(void) = EnterFunction : +# 754| mu754_2(unknown) = AliasedDefinition : +# 754| mu754_3(unknown) = UnmodeledDefinition : +# 754| r754_4(glval) = InitializeThis : +#-----| r0_1(glval) = VariableAddress[p#0] : +#-----| m0_2(Middle &) = InitializeParameter[p#0] : &:r0_1 +#-----| r0_3(Middle &) = Load : &:r0_1, m0_2 +#-----| mu0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 +#-----| r0_5(Middle *) = CopyValue : r754_4 +#-----| r0_6(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_5 +# 754| r754_5(glval) = FunctionAddress[operator=] : +#-----| r0_7(glval) = VariableAddress[p#0] : +#-----| r0_8(Middle &) = Load : &:r0_7, m0_2 +#-----| r0_9(glval) = CopyValue : r0_8 +#-----| r0_10(Middle *) = CopyValue : r0_9 +#-----| r0_11(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_10 +#-----| r0_12(glval) = CopyValue : r0_11 +#-----| r0_13(Base &) = CopyValue : r0_12 +# 754| r754_6(Base &) = Call : func:r754_5, this:r0_6, 0:r0_13 +# 754| mu754_7(unknown) = ^CallSideEffect : ~mu754_3 +#-----| v0_14(void) = ^BufferReadSideEffect[-1] : &:r0_6, ~mu754_3 +#-----| v0_15(void) = ^BufferReadSideEffect[0] : &:r0_13, ~mu754_3 +#-----| mu0_16(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_6 +#-----| mu0_17(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_13 +#-----| r0_18(glval) = CopyValue : r754_6 +#-----| r0_19(Middle *) = CopyValue : r754_4 +#-----| r0_20(glval) = FieldAddress[middle_s] : r0_19 +#-----| r0_21(String *) = CopyValue : r0_20 +# 754| r754_8(glval) = FunctionAddress[operator=] : +#-----| r0_22(glval) = VariableAddress[p#0] : +#-----| r0_23(Middle &) = Load : &:r0_22, m0_2 +#-----| r0_24(glval) = CopyValue : r0_23 +#-----| r0_25(glval) = FieldAddress[middle_s] : r0_24 +#-----| r0_26(String &) = CopyValue : r0_25 +# 754| r754_9(String &) = Call : func:r754_8, this:r0_21, 0:r0_26 +# 754| mu754_10(unknown) = ^CallSideEffect : ~mu754_3 +#-----| v0_27(void) = ^BufferReadSideEffect[-1] : &:r0_21, ~mu754_3 +#-----| v0_28(void) = ^BufferReadSideEffect[0] : &:r0_26, ~mu754_3 +#-----| mu0_29(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_21 +#-----| mu0_30(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_26 +#-----| r0_31(glval) = CopyValue : r754_9 +#-----| r0_32(glval) = VariableAddress[#return] : +#-----| r0_33(Middle *) = CopyValue : r754_4 +#-----| r0_34(glval) = CopyValue : r0_33 +#-----| r0_35(Middle &) = CopyValue : r0_34 +#-----| m0_36(Middle &) = Store : &:r0_32, r0_35 +#-----| v0_37(void) = ReturnIndirection : &:r0_3, ~mu754_3 +# 754| r754_11(glval) = VariableAddress[#return] : +# 754| v754_12(void) = ReturnValue : &:r754_11, m0_36 +# 754| v754_13(void) = UnmodeledUse : mu* +# 754| v754_14(void) = AliasedUse : ~mu754_3 +# 754| v754_15(void) = ExitFunction : + +# 757| void Middle::Middle() +# 757| Block 0 +# 757| v757_1(void) = EnterFunction : +# 757| mu757_2(unknown) = AliasedDefinition : +# 757| mu757_3(unknown) = UnmodeledDefinition : +# 757| r757_4(glval) = InitializeThis : +# 757| r757_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r757_4 +# 757| r757_6(glval) = FunctionAddress[Base] : +# 757| v757_7(void) = Call : func:r757_6, this:r757_5 +# 757| mu757_8(unknown) = ^CallSideEffect : ~mu757_3 +# 757| mu757_9(Base) = ^IndirectMayWriteSideEffect[-1] : &:r757_5 +# 757| r757_10(glval) = FieldAddress[middle_s] : r757_4 +# 757| r757_11(glval) = FunctionAddress[String] : +# 757| v757_12(void) = Call : func:r757_11, this:r757_10 +# 757| mu757_13(unknown) = ^CallSideEffect : ~mu757_3 +# 757| mu757_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r757_10 +# 758| v758_1(void) = NoOp : +# 757| v757_15(void) = ReturnVoid : +# 757| v757_16(void) = UnmodeledUse : mu* +# 757| v757_17(void) = AliasedUse : ~mu757_3 +# 757| v757_18(void) = ExitFunction : + +# 759| void Middle::~Middle() +# 759| Block 0 +# 759| v759_1(void) = EnterFunction : +# 759| mu759_2(unknown) = AliasedDefinition : +# 759| mu759_3(unknown) = UnmodeledDefinition : +# 759| r759_4(glval) = InitializeThis : +# 760| v760_1(void) = NoOp : +# 760| r760_2(glval) = FieldAddress[middle_s] : r759_4 +# 760| r760_3(glval) = FunctionAddress[~String] : +# 760| v760_4(void) = Call : func:r760_3, this:r760_2 +# 760| mu760_5(unknown) = ^CallSideEffect : ~mu759_3 +# 760| r760_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r759_4 +# 760| r760_7(glval) = FunctionAddress[~Base] : +# 760| v760_8(void) = Call : func:r760_7, this:r760_6 +# 760| mu760_9(unknown) = ^CallSideEffect : ~mu759_3 +# 759| v759_5(void) = ReturnVoid : +# 759| v759_6(void) = UnmodeledUse : mu* +# 759| v759_7(void) = AliasedUse : ~mu759_3 +# 759| v759_8(void) = ExitFunction : + +# 763| Derived& Derived::operator=(Derived const&) +# 763| Block 0 +# 763| v763_1(void) = EnterFunction : +# 763| mu763_2(unknown) = AliasedDefinition : +# 763| mu763_3(unknown) = UnmodeledDefinition : +# 763| r763_4(glval) = InitializeThis : +#-----| r0_1(glval) = VariableAddress[p#0] : +#-----| m0_2(Derived &) = InitializeParameter[p#0] : &:r0_1 +#-----| r0_3(Derived &) = Load : &:r0_1, m0_2 +#-----| mu0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 +#-----| r0_5(Derived *) = CopyValue : r763_4 +#-----| r0_6(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_5 +# 763| r763_5(glval) = FunctionAddress[operator=] : +#-----| r0_7(glval) = VariableAddress[p#0] : +#-----| r0_8(Derived &) = Load : &:r0_7, m0_2 +#-----| r0_9(glval) = CopyValue : r0_8 +#-----| r0_10(Derived *) = CopyValue : r0_9 +#-----| r0_11(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_10 +#-----| r0_12(glval) = CopyValue : r0_11 +#-----| r0_13(Middle &) = CopyValue : r0_12 +# 763| r763_6(Middle &) = Call : func:r763_5, this:r0_6, 0:r0_13 +# 763| mu763_7(unknown) = ^CallSideEffect : ~mu763_3 +#-----| v0_14(void) = ^BufferReadSideEffect[-1] : &:r0_6, ~mu763_3 +#-----| v0_15(void) = ^BufferReadSideEffect[0] : &:r0_13, ~mu763_3 +#-----| mu0_16(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_6 +#-----| mu0_17(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_13 +#-----| r0_18(glval) = CopyValue : r763_6 +#-----| r0_19(Derived *) = CopyValue : r763_4 +#-----| r0_20(glval) = FieldAddress[derived_s] : r0_19 +#-----| r0_21(String *) = CopyValue : r0_20 +# 763| r763_8(glval) = FunctionAddress[operator=] : +#-----| r0_22(glval) = VariableAddress[p#0] : +#-----| r0_23(Derived &) = Load : &:r0_22, m0_2 +#-----| r0_24(glval) = CopyValue : r0_23 +#-----| r0_25(glval) = FieldAddress[derived_s] : r0_24 +#-----| r0_26(String &) = CopyValue : r0_25 +# 763| r763_9(String &) = Call : func:r763_8, this:r0_21, 0:r0_26 +# 763| mu763_10(unknown) = ^CallSideEffect : ~mu763_3 +#-----| v0_27(void) = ^BufferReadSideEffect[-1] : &:r0_21, ~mu763_3 +#-----| v0_28(void) = ^BufferReadSideEffect[0] : &:r0_26, ~mu763_3 +#-----| mu0_29(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_21 +#-----| mu0_30(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_26 +#-----| r0_31(glval) = CopyValue : r763_9 +#-----| r0_32(glval) = VariableAddress[#return] : +#-----| r0_33(Derived *) = CopyValue : r763_4 +#-----| r0_34(glval) = CopyValue : r0_33 +#-----| r0_35(Derived &) = CopyValue : r0_34 +#-----| m0_36(Derived &) = Store : &:r0_32, r0_35 +#-----| v0_37(void) = ReturnIndirection : &:r0_3, ~mu763_3 +# 763| r763_11(glval) = VariableAddress[#return] : +# 763| v763_12(void) = ReturnValue : &:r763_11, m0_36 +# 763| v763_13(void) = UnmodeledUse : mu* +# 763| v763_14(void) = AliasedUse : ~mu763_3 +# 763| v763_15(void) = ExitFunction : + +# 766| void Derived::Derived() +# 766| Block 0 +# 766| v766_1(void) = EnterFunction : +# 766| mu766_2(unknown) = AliasedDefinition : +# 766| mu766_3(unknown) = UnmodeledDefinition : +# 766| r766_4(glval) = InitializeThis : +# 766| r766_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r766_4 +# 766| r766_6(glval) = FunctionAddress[Middle] : +# 766| v766_7(void) = Call : func:r766_6, this:r766_5 +# 766| mu766_8(unknown) = ^CallSideEffect : ~mu766_3 +# 766| mu766_9(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r766_5 +# 766| r766_10(glval) = FieldAddress[derived_s] : r766_4 +# 766| r766_11(glval) = FunctionAddress[String] : +# 766| v766_12(void) = Call : func:r766_11, this:r766_10 +# 766| mu766_13(unknown) = ^CallSideEffect : ~mu766_3 +# 766| mu766_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r766_10 +# 767| v767_1(void) = NoOp : +# 766| v766_15(void) = ReturnVoid : +# 766| v766_16(void) = UnmodeledUse : mu* +# 766| v766_17(void) = AliasedUse : ~mu766_3 +# 766| v766_18(void) = ExitFunction : + +# 768| void Derived::~Derived() +# 768| Block 0 +# 768| v768_1(void) = EnterFunction : +# 768| mu768_2(unknown) = AliasedDefinition : +# 768| mu768_3(unknown) = UnmodeledDefinition : +# 768| r768_4(glval) = InitializeThis : +# 769| v769_1(void) = NoOp : +# 769| r769_2(glval) = FieldAddress[derived_s] : r768_4 +# 769| r769_3(glval) = FunctionAddress[~String] : +# 769| v769_4(void) = Call : func:r769_3, this:r769_2 +# 769| mu769_5(unknown) = ^CallSideEffect : ~mu768_3 +# 769| r769_6(glval) = ConvertToNonVirtualBase[Derived : Middle] : r768_4 +# 769| r769_7(glval) = FunctionAddress[~Middle] : +# 769| v769_8(void) = Call : func:r769_7, this:r769_6 +# 769| mu769_9(unknown) = ^CallSideEffect : ~mu768_3 +# 768| v768_5(void) = ReturnVoid : +# 768| v768_6(void) = UnmodeledUse : mu* +# 768| v768_7(void) = AliasedUse : ~mu768_3 +# 768| v768_8(void) = ExitFunction : + +# 775| void MiddleVB1::MiddleVB1() +# 775| Block 0 +# 775| v775_1(void) = EnterFunction : +# 775| mu775_2(unknown) = AliasedDefinition : +# 775| mu775_3(unknown) = UnmodeledDefinition : +# 775| r775_4(glval) = InitializeThis : +# 775| r775_5(glval) = ConvertToNonVirtualBase[MiddleVB1 : Base] : r775_4 +# 775| r775_6(glval) = FunctionAddress[Base] : +# 775| v775_7(void) = Call : func:r775_6, this:r775_5 +# 775| mu775_8(unknown) = ^CallSideEffect : ~mu775_3 +# 775| mu775_9(Base) = ^IndirectMayWriteSideEffect[-1] : &:r775_5 +# 775| r775_10(glval) = FieldAddress[middlevb1_s] : r775_4 +# 775| r775_11(glval) = FunctionAddress[String] : +# 775| v775_12(void) = Call : func:r775_11, this:r775_10 +# 775| mu775_13(unknown) = ^CallSideEffect : ~mu775_3 +# 775| mu775_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r775_10 +# 776| v776_1(void) = NoOp : +# 775| v775_15(void) = ReturnVoid : +# 775| v775_16(void) = UnmodeledUse : mu* +# 775| v775_17(void) = AliasedUse : ~mu775_3 +# 775| v775_18(void) = ExitFunction : + +# 777| void MiddleVB1::~MiddleVB1() +# 777| Block 0 +# 777| v777_1(void) = EnterFunction : +# 777| mu777_2(unknown) = AliasedDefinition : +# 777| mu777_3(unknown) = UnmodeledDefinition : +# 777| r777_4(glval) = InitializeThis : +# 778| v778_1(void) = NoOp : +# 778| r778_2(glval) = FieldAddress[middlevb1_s] : r777_4 +# 778| r778_3(glval) = FunctionAddress[~String] : +# 778| v778_4(void) = Call : func:r778_3, this:r778_2 +# 778| mu778_5(unknown) = ^CallSideEffect : ~mu777_3 +# 778| r778_6(glval) = ConvertToNonVirtualBase[MiddleVB1 : Base] : r777_4 +# 778| r778_7(glval) = FunctionAddress[~Base] : +# 778| v778_8(void) = Call : func:r778_7, this:r778_6 +# 778| mu778_9(unknown) = ^CallSideEffect : ~mu777_3 +# 777| v777_5(void) = ReturnVoid : +# 777| v777_6(void) = UnmodeledUse : mu* +# 777| v777_7(void) = AliasedUse : ~mu777_3 +# 777| v777_8(void) = ExitFunction : + +# 784| void MiddleVB2::MiddleVB2() +# 784| Block 0 +# 784| v784_1(void) = EnterFunction : +# 784| mu784_2(unknown) = AliasedDefinition : +# 784| mu784_3(unknown) = UnmodeledDefinition : +# 784| r784_4(glval) = InitializeThis : +# 784| r784_5(glval) = ConvertToNonVirtualBase[MiddleVB2 : Base] : r784_4 +# 784| r784_6(glval) = FunctionAddress[Base] : +# 784| v784_7(void) = Call : func:r784_6, this:r784_5 +# 784| mu784_8(unknown) = ^CallSideEffect : ~mu784_3 +# 784| mu784_9(Base) = ^IndirectMayWriteSideEffect[-1] : &:r784_5 +# 784| r784_10(glval) = FieldAddress[middlevb2_s] : r784_4 +# 784| r784_11(glval) = FunctionAddress[String] : +# 784| v784_12(void) = Call : func:r784_11, this:r784_10 +# 784| mu784_13(unknown) = ^CallSideEffect : ~mu784_3 +# 784| mu784_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r784_10 +# 785| v785_1(void) = NoOp : +# 784| v784_15(void) = ReturnVoid : +# 784| v784_16(void) = UnmodeledUse : mu* +# 784| v784_17(void) = AliasedUse : ~mu784_3 +# 784| v784_18(void) = ExitFunction : + +# 786| void MiddleVB2::~MiddleVB2() +# 786| Block 0 +# 786| v786_1(void) = EnterFunction : +# 786| mu786_2(unknown) = AliasedDefinition : +# 786| mu786_3(unknown) = UnmodeledDefinition : +# 786| r786_4(glval) = InitializeThis : +# 787| v787_1(void) = NoOp : +# 787| r787_2(glval) = FieldAddress[middlevb2_s] : r786_4 +# 787| r787_3(glval) = FunctionAddress[~String] : +# 787| v787_4(void) = Call : func:r787_3, this:r787_2 +# 787| mu787_5(unknown) = ^CallSideEffect : ~mu786_3 +# 787| r787_6(glval) = ConvertToNonVirtualBase[MiddleVB2 : Base] : r786_4 +# 787| r787_7(glval) = FunctionAddress[~Base] : +# 787| v787_8(void) = Call : func:r787_7, this:r787_6 +# 787| mu787_9(unknown) = ^CallSideEffect : ~mu786_3 +# 786| v786_5(void) = ReturnVoid : +# 786| v786_6(void) = UnmodeledUse : mu* +# 786| v786_7(void) = AliasedUse : ~mu786_3 +# 786| v786_8(void) = ExitFunction : + +# 793| void DerivedVB::DerivedVB() +# 793| Block 0 +# 793| v793_1(void) = EnterFunction : +# 793| mu793_2(unknown) = AliasedDefinition : +# 793| mu793_3(unknown) = UnmodeledDefinition : +# 793| r793_4(glval) = InitializeThis : +# 793| r793_5(glval) = ConvertToNonVirtualBase[DerivedVB : Base] : r793_4 +# 793| r793_6(glval) = FunctionAddress[Base] : +# 793| v793_7(void) = Call : func:r793_6, this:r793_5 +# 793| mu793_8(unknown) = ^CallSideEffect : ~mu793_3 +# 793| mu793_9(Base) = ^IndirectMayWriteSideEffect[-1] : &:r793_5 +# 793| r793_10(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB1] : r793_4 +# 793| r793_11(glval) = FunctionAddress[MiddleVB1] : +# 793| v793_12(void) = Call : func:r793_11, this:r793_10 +# 793| mu793_13(unknown) = ^CallSideEffect : ~mu793_3 +# 793| mu793_14(MiddleVB1) = ^IndirectMayWriteSideEffect[-1] : &:r793_10 +# 793| r793_15(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB2] : r793_4 +# 793| r793_16(glval) = FunctionAddress[MiddleVB2] : +# 793| v793_17(void) = Call : func:r793_16, this:r793_15 +# 793| mu793_18(unknown) = ^CallSideEffect : ~mu793_3 +# 793| mu793_19(MiddleVB2) = ^IndirectMayWriteSideEffect[-1] : &:r793_15 +# 793| r793_20(glval) = FieldAddress[derivedvb_s] : r793_4 +# 793| r793_21(glval) = FunctionAddress[String] : +# 793| v793_22(void) = Call : func:r793_21, this:r793_20 +# 793| mu793_23(unknown) = ^CallSideEffect : ~mu793_3 +# 793| mu793_24(String) = ^IndirectMayWriteSideEffect[-1] : &:r793_20 +# 794| v794_1(void) = NoOp : +# 793| v793_25(void) = ReturnVoid : +# 793| v793_26(void) = UnmodeledUse : mu* +# 793| v793_27(void) = AliasedUse : ~mu793_3 +# 793| v793_28(void) = ExitFunction : + +# 795| void DerivedVB::~DerivedVB() +# 795| Block 0 +# 795| v795_1(void) = EnterFunction : +# 795| mu795_2(unknown) = AliasedDefinition : +# 795| mu795_3(unknown) = UnmodeledDefinition : +# 795| r795_4(glval) = InitializeThis : +# 796| v796_1(void) = NoOp : +# 796| r796_2(glval) = FieldAddress[derivedvb_s] : r795_4 +# 796| r796_3(glval) = FunctionAddress[~String] : +# 796| v796_4(void) = Call : func:r796_3, this:r796_2 +# 796| mu796_5(unknown) = ^CallSideEffect : ~mu795_3 +# 796| r796_6(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB2] : r795_4 +# 796| r796_7(glval) = FunctionAddress[~MiddleVB2] : +# 796| v796_8(void) = Call : func:r796_7, this:r796_6 +# 796| mu796_9(unknown) = ^CallSideEffect : ~mu795_3 +# 796| r796_10(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB1] : r795_4 +# 796| r796_11(glval) = FunctionAddress[~MiddleVB1] : +# 796| v796_12(void) = Call : func:r796_11, this:r796_10 +# 796| mu796_13(unknown) = ^CallSideEffect : ~mu795_3 +# 796| r796_14(glval) = ConvertToNonVirtualBase[DerivedVB : Base] : r795_4 +# 796| r796_15(glval) = FunctionAddress[~Base] : +# 796| v796_16(void) = Call : func:r796_15, this:r796_14 +# 796| mu796_17(unknown) = ^CallSideEffect : ~mu795_3 +# 795| v795_5(void) = ReturnVoid : +# 795| v795_6(void) = UnmodeledUse : mu* +# 795| v795_7(void) = AliasedUse : ~mu795_3 +# 795| v795_8(void) = ExitFunction : + +# 799| void HierarchyConversions() +# 799| Block 0 +# 799| v799_1(void) = EnterFunction : +# 799| mu799_2(unknown) = AliasedDefinition : +# 799| mu799_3(unknown) = UnmodeledDefinition : +# 800| r800_1(glval) = VariableAddress[b] : +# 800| mu800_2(Base) = Uninitialized[b] : &:r800_1 +# 800| r800_3(glval) = FunctionAddress[Base] : +# 800| v800_4(void) = Call : func:r800_3, this:r800_1 +# 800| mu800_5(unknown) = ^CallSideEffect : ~mu799_3 +# 800| mu800_6(Base) = ^IndirectMayWriteSideEffect[-1] : &:r800_1 +# 801| r801_1(glval) = VariableAddress[m] : +# 801| mu801_2(Middle) = Uninitialized[m] : &:r801_1 +# 801| r801_3(glval) = FunctionAddress[Middle] : +# 801| v801_4(void) = Call : func:r801_3, this:r801_1 +# 801| mu801_5(unknown) = ^CallSideEffect : ~mu799_3 +# 801| mu801_6(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r801_1 +# 802| r802_1(glval) = VariableAddress[d] : +# 802| mu802_2(Derived) = Uninitialized[d] : &:r802_1 +# 802| r802_3(glval) = FunctionAddress[Derived] : +# 802| v802_4(void) = Call : func:r802_3, this:r802_1 +# 802| mu802_5(unknown) = ^CallSideEffect : ~mu799_3 +# 802| mu802_6(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r802_1 +# 804| r804_1(glval) = VariableAddress[pb] : +# 804| r804_2(glval) = VariableAddress[b] : +# 804| r804_3(Base *) = CopyValue : r804_2 +# 804| m804_4(Base *) = Store : &:r804_1, r804_3 +# 805| r805_1(glval) = VariableAddress[pm] : +# 805| r805_2(glval) = VariableAddress[m] : +# 805| r805_3(Middle *) = CopyValue : r805_2 +# 805| m805_4(Middle *) = Store : &:r805_1, r805_3 +# 806| r806_1(glval) = VariableAddress[pd] : +# 806| r806_2(glval) = VariableAddress[d] : +# 806| r806_3(Derived *) = CopyValue : r806_2 +# 806| m806_4(Derived *) = Store : &:r806_1, r806_3 +# 808| r808_1(glval) = VariableAddress[b] : +# 808| r808_2(glval) = FunctionAddress[operator=] : +# 808| r808_3(glval) = VariableAddress[m] : +# 808| r808_4(glval) = ConvertToNonVirtualBase[Middle : Base] : r808_3 +# 808| r808_5(Base &) = CopyValue : r808_4 +# 808| r808_6(Base &) = Call : func:r808_2, this:r808_1, 0:r808_5 +# 808| mu808_7(unknown) = ^CallSideEffect : ~mu799_3 +# 808| v808_8(void) = ^BufferReadSideEffect[-1] : &:r808_1, ~mu799_3 +# 808| v808_9(void) = ^BufferReadSideEffect[0] : &:r808_5, ~mu799_3 +# 808| mu808_10(Base) = ^IndirectMayWriteSideEffect[-1] : &:r808_1 +# 808| mu808_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r808_5 +# 808| r808_12(glval) = CopyValue : r808_6 +# 809| r809_1(glval) = VariableAddress[b] : +# 809| r809_2(glval) = FunctionAddress[operator=] : +# 809| r809_3(glval) = FunctionAddress[Base] : +# 809| r809_4(glval) = VariableAddress[m] : +# 809| r809_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r809_4 +# 809| r809_6(Base &) = CopyValue : r809_5 +# 809| v809_7(void) = Call : func:r809_3, 0:r809_6 +# 809| mu809_8(unknown) = ^CallSideEffect : ~mu799_3 +# 809| mu809_9(Base) = ^IndirectMayWriteSideEffect[-1] : +# 809| v809_10(void) = ^BufferReadSideEffect[0] : &:r809_6, ~mu799_3 +# 809| mu809_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r809_6 +# 809| r809_12(glval) = Convert : v809_7 +# 809| r809_13(Base &) = CopyValue : r809_12 +# 809| r809_14(Base &) = Call : func:r809_2, this:r809_1, 0:r809_13 +# 809| mu809_15(unknown) = ^CallSideEffect : ~mu799_3 +# 809| v809_16(void) = ^BufferReadSideEffect[-1] : &:r809_1, ~mu799_3 +# 809| v809_17(void) = ^BufferReadSideEffect[0] : &:r809_13, ~mu799_3 +# 809| mu809_18(Base) = ^IndirectMayWriteSideEffect[-1] : &:r809_1 +# 809| mu809_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r809_13 +# 809| r809_20(glval) = CopyValue : r809_14 +# 810| r810_1(glval) = VariableAddress[b] : +# 810| r810_2(glval) = FunctionAddress[operator=] : +# 810| r810_3(glval) = FunctionAddress[Base] : +# 810| r810_4(glval) = VariableAddress[m] : +# 810| r810_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r810_4 +# 810| r810_6(Base &) = CopyValue : r810_5 +# 810| v810_7(void) = Call : func:r810_3, 0:r810_6 +# 810| mu810_8(unknown) = ^CallSideEffect : ~mu799_3 +# 810| mu810_9(Base) = ^IndirectMayWriteSideEffect[-1] : +# 810| v810_10(void) = ^BufferReadSideEffect[0] : &:r810_6, ~mu799_3 +# 810| mu810_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r810_6 +# 810| r810_12(glval) = Convert : v810_7 +# 810| r810_13(Base &) = CopyValue : r810_12 +# 810| r810_14(Base &) = Call : func:r810_2, this:r810_1, 0:r810_13 +# 810| mu810_15(unknown) = ^CallSideEffect : ~mu799_3 +# 810| v810_16(void) = ^BufferReadSideEffect[-1] : &:r810_1, ~mu799_3 +# 810| v810_17(void) = ^BufferReadSideEffect[0] : &:r810_13, ~mu799_3 +# 810| mu810_18(Base) = ^IndirectMayWriteSideEffect[-1] : &:r810_1 +# 810| mu810_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r810_13 +# 810| r810_20(glval) = CopyValue : r810_14 +# 811| r811_1(glval) = VariableAddress[pm] : +# 811| r811_2(Middle *) = Load : &:r811_1, m805_4 +# 811| r811_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r811_2 +# 811| r811_4(glval) = VariableAddress[pb] : +# 811| m811_5(Base *) = Store : &:r811_4, r811_3 +# 812| r812_1(glval) = VariableAddress[pm] : +# 812| r812_2(Middle *) = Load : &:r812_1, m805_4 +# 812| r812_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r812_2 +# 812| r812_4(glval) = VariableAddress[pb] : +# 812| m812_5(Base *) = Store : &:r812_4, r812_3 +# 813| r813_1(glval) = VariableAddress[pm] : +# 813| r813_2(Middle *) = Load : &:r813_1, m805_4 +# 813| r813_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r813_2 +# 813| r813_4(glval) = VariableAddress[pb] : +# 813| m813_5(Base *) = Store : &:r813_4, r813_3 +# 814| r814_1(glval) = VariableAddress[pm] : +# 814| r814_2(Middle *) = Load : &:r814_1, m805_4 +# 814| r814_3(Base *) = Convert : r814_2 +# 814| r814_4(glval) = VariableAddress[pb] : +# 814| m814_5(Base *) = Store : &:r814_4, r814_3 +# 816| r816_1(glval) = VariableAddress[m] : +# 816| r816_2(glval) = FunctionAddress[operator=] : +# 816| r816_3(glval) = VariableAddress[b] : +# 816| r816_4(glval) = ConvertToDerived[Middle : Base] : r816_3 +# 816| r816_5(glval) = Convert : r816_4 +# 816| r816_6(Middle &) = CopyValue : r816_5 +# 816| r816_7(Middle &) = Call : func:r816_2, this:r816_1, 0:r816_6 +# 816| mu816_8(unknown) = ^CallSideEffect : ~mu799_3 +# 816| v816_9(void) = ^BufferReadSideEffect[-1] : &:r816_1, ~mu799_3 +# 816| v816_10(void) = ^BufferReadSideEffect[0] : &:r816_6, ~mu799_3 +# 816| mu816_11(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r816_1 +# 816| mu816_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r816_6 +# 816| r816_13(glval) = CopyValue : r816_7 +# 817| r817_1(glval) = VariableAddress[m] : +# 817| r817_2(glval) = FunctionAddress[operator=] : +# 817| r817_3(glval) = VariableAddress[b] : +# 817| r817_4(glval) = ConvertToDerived[Middle : Base] : r817_3 +# 817| r817_5(glval) = Convert : r817_4 +# 817| r817_6(Middle &) = CopyValue : r817_5 +# 817| r817_7(Middle &) = Call : func:r817_2, this:r817_1, 0:r817_6 +# 817| mu817_8(unknown) = ^CallSideEffect : ~mu799_3 +# 817| v817_9(void) = ^BufferReadSideEffect[-1] : &:r817_1, ~mu799_3 +# 817| v817_10(void) = ^BufferReadSideEffect[0] : &:r817_6, ~mu799_3 +# 817| mu817_11(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r817_1 +# 817| mu817_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r817_6 +# 817| r817_13(glval) = CopyValue : r817_7 +# 818| r818_1(glval) = VariableAddress[pb] : +# 818| r818_2(Base *) = Load : &:r818_1, m814_5 +# 818| r818_3(Middle *) = ConvertToDerived[Middle : Base] : r818_2 +# 818| r818_4(glval) = VariableAddress[pm] : +# 818| m818_5(Middle *) = Store : &:r818_4, r818_3 +# 819| r819_1(glval) = VariableAddress[pb] : +# 819| r819_2(Base *) = Load : &:r819_1, m814_5 +# 819| r819_3(Middle *) = ConvertToDerived[Middle : Base] : r819_2 +# 819| r819_4(glval) = VariableAddress[pm] : +# 819| m819_5(Middle *) = Store : &:r819_4, r819_3 +# 820| r820_1(glval) = VariableAddress[pb] : +# 820| r820_2(Base *) = Load : &:r820_1, m814_5 +# 820| r820_3(Middle *) = Convert : r820_2 +# 820| r820_4(glval) = VariableAddress[pm] : +# 820| m820_5(Middle *) = Store : &:r820_4, r820_3 +# 822| r822_1(glval) = VariableAddress[b] : +# 822| r822_2(glval) = FunctionAddress[operator=] : +# 822| r822_3(glval) = VariableAddress[d] : +# 822| r822_4(glval) = ConvertToNonVirtualBase[Derived : Middle] : r822_3 +# 822| r822_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r822_4 +# 822| r822_6(Base &) = CopyValue : r822_5 +# 822| r822_7(Base &) = Call : func:r822_2, this:r822_1, 0:r822_6 +# 822| mu822_8(unknown) = ^CallSideEffect : ~mu799_3 +# 822| v822_9(void) = ^BufferReadSideEffect[-1] : &:r822_1, ~mu799_3 +# 822| v822_10(void) = ^BufferReadSideEffect[0] : &:r822_6, ~mu799_3 +# 822| mu822_11(Base) = ^IndirectMayWriteSideEffect[-1] : &:r822_1 +# 822| mu822_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r822_6 +# 822| r822_13(glval) = CopyValue : r822_7 +# 823| r823_1(glval) = VariableAddress[b] : +# 823| r823_2(glval) = FunctionAddress[operator=] : +# 823| r823_3(glval) = FunctionAddress[Base] : +# 823| r823_4(glval) = VariableAddress[d] : +# 823| r823_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r823_4 +# 823| r823_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r823_5 +# 823| r823_7(Base &) = CopyValue : r823_6 +# 823| v823_8(void) = Call : func:r823_3, 0:r823_7 +# 823| mu823_9(unknown) = ^CallSideEffect : ~mu799_3 +# 823| mu823_10(Base) = ^IndirectMayWriteSideEffect[-1] : +# 823| v823_11(void) = ^BufferReadSideEffect[0] : &:r823_7, ~mu799_3 +# 823| mu823_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r823_7 +# 823| r823_13(glval) = Convert : v823_8 +# 823| r823_14(Base &) = CopyValue : r823_13 +# 823| r823_15(Base &) = Call : func:r823_2, this:r823_1, 0:r823_14 +# 823| mu823_16(unknown) = ^CallSideEffect : ~mu799_3 +# 823| v823_17(void) = ^BufferReadSideEffect[-1] : &:r823_1, ~mu799_3 +# 823| v823_18(void) = ^BufferReadSideEffect[0] : &:r823_14, ~mu799_3 +# 823| mu823_19(Base) = ^IndirectMayWriteSideEffect[-1] : &:r823_1 +# 823| mu823_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r823_14 +# 823| r823_21(glval) = CopyValue : r823_15 +# 824| r824_1(glval) = VariableAddress[b] : +# 824| r824_2(glval) = FunctionAddress[operator=] : +# 824| r824_3(glval) = FunctionAddress[Base] : +# 824| r824_4(glval) = VariableAddress[d] : +# 824| r824_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r824_4 +# 824| r824_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r824_5 +# 824| r824_7(Base &) = CopyValue : r824_6 +# 824| v824_8(void) = Call : func:r824_3, 0:r824_7 +# 824| mu824_9(unknown) = ^CallSideEffect : ~mu799_3 +# 824| mu824_10(Base) = ^IndirectMayWriteSideEffect[-1] : +# 824| v824_11(void) = ^BufferReadSideEffect[0] : &:r824_7, ~mu799_3 +# 824| mu824_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r824_7 +# 824| r824_13(glval) = Convert : v824_8 +# 824| r824_14(Base &) = CopyValue : r824_13 +# 824| r824_15(Base &) = Call : func:r824_2, this:r824_1, 0:r824_14 +# 824| mu824_16(unknown) = ^CallSideEffect : ~mu799_3 +# 824| v824_17(void) = ^BufferReadSideEffect[-1] : &:r824_1, ~mu799_3 +# 824| v824_18(void) = ^BufferReadSideEffect[0] : &:r824_14, ~mu799_3 +# 824| mu824_19(Base) = ^IndirectMayWriteSideEffect[-1] : &:r824_1 +# 824| mu824_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r824_14 +# 824| r824_21(glval) = CopyValue : r824_15 +# 825| r825_1(glval) = VariableAddress[pd] : +# 825| r825_2(Derived *) = Load : &:r825_1, m806_4 +# 825| r825_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r825_2 +# 825| r825_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r825_3 +# 825| r825_5(glval) = VariableAddress[pb] : +# 825| m825_6(Base *) = Store : &:r825_5, r825_4 +# 826| r826_1(glval) = VariableAddress[pd] : +# 826| r826_2(Derived *) = Load : &:r826_1, m806_4 +# 826| r826_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r826_2 +# 826| r826_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r826_3 +# 826| r826_5(glval) = VariableAddress[pb] : +# 826| m826_6(Base *) = Store : &:r826_5, r826_4 +# 827| r827_1(glval) = VariableAddress[pd] : +# 827| r827_2(Derived *) = Load : &:r827_1, m806_4 +# 827| r827_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r827_2 +# 827| r827_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r827_3 +# 827| r827_5(glval) = VariableAddress[pb] : +# 827| m827_6(Base *) = Store : &:r827_5, r827_4 +# 828| r828_1(glval) = VariableAddress[pd] : +# 828| r828_2(Derived *) = Load : &:r828_1, m806_4 +# 828| r828_3(Base *) = Convert : r828_2 +# 828| r828_4(glval) = VariableAddress[pb] : +# 828| m828_5(Base *) = Store : &:r828_4, r828_3 +# 830| r830_1(glval) = VariableAddress[d] : +# 830| r830_2(glval) = FunctionAddress[operator=] : +# 830| r830_3(glval) = VariableAddress[b] : +# 830| r830_4(glval) = ConvertToDerived[Middle : Base] : r830_3 +# 830| r830_5(glval) = ConvertToDerived[Derived : Middle] : r830_4 +# 830| r830_6(glval) = Convert : r830_5 +# 830| r830_7(Derived &) = CopyValue : r830_6 +# 830| r830_8(Derived &) = Call : func:r830_2, this:r830_1, 0:r830_7 +# 830| mu830_9(unknown) = ^CallSideEffect : ~mu799_3 +# 830| v830_10(void) = ^BufferReadSideEffect[-1] : &:r830_1, ~mu799_3 +# 830| v830_11(void) = ^BufferReadSideEffect[0] : &:r830_7, ~mu799_3 +# 830| mu830_12(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r830_1 +# 830| mu830_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r830_7 +# 830| r830_14(glval) = CopyValue : r830_8 +# 831| r831_1(glval) = VariableAddress[d] : +# 831| r831_2(glval) = FunctionAddress[operator=] : +# 831| r831_3(glval) = VariableAddress[b] : +# 831| r831_4(glval) = ConvertToDerived[Middle : Base] : r831_3 +# 831| r831_5(glval) = ConvertToDerived[Derived : Middle] : r831_4 +# 831| r831_6(glval) = Convert : r831_5 +# 831| r831_7(Derived &) = CopyValue : r831_6 +# 831| r831_8(Derived &) = Call : func:r831_2, this:r831_1, 0:r831_7 +# 831| mu831_9(unknown) = ^CallSideEffect : ~mu799_3 +# 831| v831_10(void) = ^BufferReadSideEffect[-1] : &:r831_1, ~mu799_3 +# 831| v831_11(void) = ^BufferReadSideEffect[0] : &:r831_7, ~mu799_3 +# 831| mu831_12(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r831_1 +# 831| mu831_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r831_7 +# 831| r831_14(glval) = CopyValue : r831_8 +# 832| r832_1(glval) = VariableAddress[pb] : +# 832| r832_2(Base *) = Load : &:r832_1, m828_5 +# 832| r832_3(Middle *) = ConvertToDerived[Middle : Base] : r832_2 +# 832| r832_4(Derived *) = ConvertToDerived[Derived : Middle] : r832_3 +# 832| r832_5(glval) = VariableAddress[pd] : +# 832| m832_6(Derived *) = Store : &:r832_5, r832_4 +# 833| r833_1(glval) = VariableAddress[pb] : +# 833| r833_2(Base *) = Load : &:r833_1, m828_5 +# 833| r833_3(Middle *) = ConvertToDerived[Middle : Base] : r833_2 +# 833| r833_4(Derived *) = ConvertToDerived[Derived : Middle] : r833_3 +# 833| r833_5(glval) = VariableAddress[pd] : +# 833| m833_6(Derived *) = Store : &:r833_5, r833_4 +# 834| r834_1(glval) = VariableAddress[pb] : +# 834| r834_2(Base *) = Load : &:r834_1, m828_5 +# 834| r834_3(Derived *) = Convert : r834_2 +# 834| r834_4(glval) = VariableAddress[pd] : +# 834| m834_5(Derived *) = Store : &:r834_4, r834_3 +# 836| r836_1(glval) = VariableAddress[pmv] : +# 836| r836_2(MiddleVB1 *) = Constant[0] : +# 836| m836_3(MiddleVB1 *) = Store : &:r836_1, r836_2 +# 837| r837_1(glval) = VariableAddress[pdv] : +# 837| r837_2(DerivedVB *) = Constant[0] : +# 837| m837_3(DerivedVB *) = Store : &:r837_1, r837_2 +# 838| r838_1(glval) = VariableAddress[pmv] : +# 838| r838_2(MiddleVB1 *) = Load : &:r838_1, m836_3 +# 838| r838_3(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r838_2 +# 838| r838_4(glval) = VariableAddress[pb] : +# 838| m838_5(Base *) = Store : &:r838_4, r838_3 +# 839| r839_1(glval) = VariableAddress[pdv] : +# 839| r839_2(DerivedVB *) = Load : &:r839_1, m837_3 +# 839| r839_3(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r839_2 +# 839| r839_4(glval) = VariableAddress[pb] : +# 839| m839_5(Base *) = Store : &:r839_4, r839_3 +# 840| v840_1(void) = NoOp : +# 799| v799_4(void) = ReturnVoid : +# 799| v799_5(void) = UnmodeledUse : mu* +# 799| v799_6(void) = AliasedUse : ~mu799_3 +# 799| v799_7(void) = ExitFunction : + +# 842| void PolymorphicBase::PolymorphicBase() +# 842| Block 0 +# 842| v842_1(void) = EnterFunction : +# 842| mu842_2(unknown) = AliasedDefinition : +# 842| mu842_3(unknown) = UnmodeledDefinition : +# 842| r842_4(glval) = InitializeThis : +# 842| v842_5(void) = NoOp : +# 842| v842_6(void) = ReturnVoid : +# 842| v842_7(void) = UnmodeledUse : mu* +# 842| v842_8(void) = AliasedUse : ~mu842_3 +# 842| v842_9(void) = ExitFunction : + +# 846| void PolymorphicDerived::PolymorphicDerived() +# 846| Block 0 +# 846| v846_1(void) = EnterFunction : +# 846| mu846_2(unknown) = AliasedDefinition : +# 846| mu846_3(unknown) = UnmodeledDefinition : +# 846| r846_4(glval) = InitializeThis : +# 846| r846_5(glval) = ConvertToNonVirtualBase[PolymorphicDerived : PolymorphicBase] : r846_4 +# 846| r846_6(glval) = FunctionAddress[PolymorphicBase] : +# 846| v846_7(void) = Call : func:r846_6, this:r846_5 +# 846| mu846_8(unknown) = ^CallSideEffect : ~mu846_3 +# 846| mu846_9(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r846_5 +# 846| v846_10(void) = NoOp : +# 846| v846_11(void) = ReturnVoid : +# 846| v846_12(void) = UnmodeledUse : mu* +# 846| v846_13(void) = AliasedUse : ~mu846_3 +# 846| v846_14(void) = ExitFunction : + +# 846| void PolymorphicDerived::~PolymorphicDerived() +# 846| Block 0 +# 846| v846_1(void) = EnterFunction : +# 846| mu846_2(unknown) = AliasedDefinition : +# 846| mu846_3(unknown) = UnmodeledDefinition : +# 846| r846_4(glval) = InitializeThis : +#-----| v0_1(void) = NoOp : +# 846| r846_5(glval) = ConvertToNonVirtualBase[PolymorphicDerived : PolymorphicBase] : r846_4 +# 846| r846_6(glval) = FunctionAddress[~PolymorphicBase] : +# 846| v846_7(void) = Call : func:r846_6, this:r846_5 +# 846| mu846_8(unknown) = ^CallSideEffect : ~mu846_3 +# 846| v846_9(void) = ReturnVoid : +# 846| v846_10(void) = UnmodeledUse : mu* +# 846| v846_11(void) = AliasedUse : ~mu846_3 +# 846| v846_12(void) = ExitFunction : + +# 849| void DynamicCast() +# 849| Block 0 +# 849| v849_1(void) = EnterFunction : +# 849| mu849_2(unknown) = AliasedDefinition : +# 849| mu849_3(unknown) = UnmodeledDefinition : +# 850| r850_1(glval) = VariableAddress[b] : +# 850| m850_2(PolymorphicBase) = Uninitialized[b] : &:r850_1 +#-----| r0_1(glval) = FunctionAddress[PolymorphicBase] : +#-----| v0_2(void) = Call : func:r0_1, this:r850_1 +#-----| mu0_3(unknown) = ^CallSideEffect : ~mu849_3 +#-----| m0_4(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r850_1 +# 851| r851_1(glval) = VariableAddress[d] : +# 851| m851_2(PolymorphicDerived) = Uninitialized[d] : &:r851_1 +# 851| r851_3(glval) = FunctionAddress[PolymorphicDerived] : +# 851| v851_4(void) = Call : func:r851_3, this:r851_1 +# 851| mu851_5(unknown) = ^CallSideEffect : ~mu849_3 +# 851| m851_6(PolymorphicDerived) = ^IndirectMayWriteSideEffect[-1] : &:r851_1 +# 853| r853_1(glval) = VariableAddress[pb] : +# 853| r853_2(glval) = VariableAddress[b] : +# 853| r853_3(PolymorphicBase *) = CopyValue : r853_2 +# 853| m853_4(PolymorphicBase *) = Store : &:r853_1, r853_3 +# 854| r854_1(glval) = VariableAddress[pd] : +# 854| r854_2(glval) = VariableAddress[d] : +# 854| r854_3(PolymorphicDerived *) = CopyValue : r854_2 +# 854| m854_4(PolymorphicDerived *) = Store : &:r854_1, r854_3 +# 857| r857_1(glval) = VariableAddress[pd] : +# 857| r857_2(PolymorphicDerived *) = Load : &:r857_1, m854_4 +# 857| r857_3(PolymorphicBase *) = CheckedConvertOrNull : r857_2 +# 857| r857_4(glval) = VariableAddress[pb] : +# 857| m857_5(PolymorphicBase *) = Store : &:r857_4, r857_3 +# 858| r858_1(glval) = VariableAddress[rb] : +# 858| r858_2(glval) = VariableAddress[d] : +# 858| r858_3(glval) = CheckedConvertOrThrow : r858_2 +# 858| r858_4(PolymorphicBase &) = CopyValue : r858_3 +# 858| m858_5(PolymorphicBase &) = Store : &:r858_1, r858_4 +# 860| r860_1(glval) = VariableAddress[pb] : +# 860| r860_2(PolymorphicBase *) = Load : &:r860_1, m857_5 +# 860| r860_3(PolymorphicDerived *) = CheckedConvertOrNull : r860_2 +# 860| r860_4(glval) = VariableAddress[pd] : +# 860| m860_5(PolymorphicDerived *) = Store : &:r860_4, r860_3 +# 861| r861_1(glval) = VariableAddress[rd] : +# 861| r861_2(glval) = VariableAddress[b] : +# 861| r861_3(glval) = CheckedConvertOrThrow : r861_2 +# 861| r861_4(PolymorphicDerived &) = CopyValue : r861_3 +# 861| m861_5(PolymorphicDerived &) = Store : &:r861_1, r861_4 +# 863| r863_1(glval) = VariableAddress[pv] : +# 863| r863_2(glval) = VariableAddress[pb] : +# 863| r863_3(PolymorphicBase *) = Load : &:r863_2, m857_5 +# 863| r863_4(void *) = DynamicCastToVoid : r863_3 +# 863| m863_5(void *) = Store : &:r863_1, r863_4 +# 864| r864_1(glval) = VariableAddress[pcv] : +# 864| r864_2(glval) = VariableAddress[pd] : +# 864| r864_3(PolymorphicDerived *) = Load : &:r864_2, m860_5 +# 864| r864_4(void *) = DynamicCastToVoid : r864_3 +# 864| m864_5(void *) = Store : &:r864_1, r864_4 +# 865| v865_1(void) = NoOp : +# 849| v849_4(void) = ReturnVoid : +# 849| v849_5(void) = UnmodeledUse : mu* +# 849| v849_6(void) = AliasedUse : ~mu849_3 +# 849| v849_7(void) = ExitFunction : + +# 867| void String::String() +# 867| Block 0 +# 867| v867_1(void) = EnterFunction : +# 867| mu867_2(unknown) = AliasedDefinition : +# 867| mu867_3(unknown) = UnmodeledDefinition : +# 867| r867_4(glval) = InitializeThis : +# 868| r868_1(glval) = FunctionAddress[String] : +# 868| r868_2(glval) = StringConstant[""] : +# 868| r868_3(char *) = Convert : r868_2 +# 868| v868_4(void) = Call : func:r868_1, this:r867_4, 0:r868_3 +# 868| mu868_5(unknown) = ^CallSideEffect : ~mu867_3 +# 868| mu868_6(String) = ^IndirectMayWriteSideEffect[-1] : &:r867_4 +# 868| v868_7(void) = ^BufferReadSideEffect[0] : &:r868_3, ~mu867_3 +# 868| mu868_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r868_3 +# 869| v869_1(void) = NoOp : +# 867| v867_5(void) = ReturnVoid : +# 867| v867_6(void) = UnmodeledUse : mu* +# 867| v867_7(void) = AliasedUse : ~mu867_3 +# 867| v867_8(void) = ExitFunction : + +# 871| void ArrayConversions() +# 871| Block 0 +# 871| v871_1(void) = EnterFunction : +# 871| mu871_2(unknown) = AliasedDefinition : +# 871| mu871_3(unknown) = UnmodeledDefinition : +# 872| r872_1(glval) = VariableAddress[a] : +# 872| m872_2(char[5]) = Uninitialized[a] : &:r872_1 +# 873| r873_1(glval) = VariableAddress[p] : +# 873| r873_2(glval) = VariableAddress[a] : +# 873| r873_3(char *) = Convert : r873_2 +# 873| r873_4(char *) = Convert : r873_3 +# 873| m873_5(char *) = Store : &:r873_1, r873_4 +# 874| r874_1(glval) = StringConstant["test"] : +# 874| r874_2(char *) = Convert : r874_1 +# 874| r874_3(glval) = VariableAddress[p] : +# 874| m874_4(char *) = Store : &:r874_3, r874_2 +# 875| r875_1(glval) = VariableAddress[a] : +# 875| r875_2(char *) = Convert : r875_1 +# 875| r875_3(int) = Constant[0] : +# 875| r875_4(glval) = PointerAdd[1] : r875_2, r875_3 +# 875| r875_5(char *) = CopyValue : r875_4 +# 875| r875_6(char *) = Convert : r875_5 +# 875| r875_7(glval) = VariableAddress[p] : +# 875| m875_8(char *) = Store : &:r875_7, r875_6 +# 876| r876_1(glval) = StringConstant["test"] : +# 876| r876_2(char *) = Convert : r876_1 +# 876| r876_3(int) = Constant[0] : +# 876| r876_4(glval) = PointerAdd[1] : r876_2, r876_3 +# 876| r876_5(char *) = CopyValue : r876_4 +# 876| r876_6(glval) = VariableAddress[p] : +# 876| m876_7(char *) = Store : &:r876_6, r876_5 +# 877| r877_1(glval) = VariableAddress[ra] : +# 877| r877_2(glval) = VariableAddress[a] : +# 877| r877_3(char(&)[5]) = CopyValue : r877_2 +# 877| m877_4(char(&)[5]) = Store : &:r877_1, r877_3 +# 878| r878_1(glval) = VariableAddress[rs] : +# 878| r878_2(glval) = StringConstant["test"] : +# 878| r878_3(char(&)[5]) = CopyValue : r878_2 +# 878| m878_4(char(&)[5]) = Store : &:r878_1, r878_3 +# 879| r879_1(glval) = VariableAddress[pa] : +# 879| r879_2(glval) = VariableAddress[a] : +# 879| r879_3(char(*)[5]) = CopyValue : r879_2 +# 879| r879_4(char(*)[5]) = Convert : r879_3 +# 879| m879_5(char(*)[5]) = Store : &:r879_1, r879_4 +# 880| r880_1(glval) = StringConstant["test"] : +# 880| r880_2(char(*)[5]) = CopyValue : r880_1 +# 880| r880_3(glval) = VariableAddress[pa] : +# 880| m880_4(char(*)[5]) = Store : &:r880_3, r880_2 +# 881| v881_1(void) = NoOp : +# 871| v871_4(void) = ReturnVoid : +# 871| v871_5(void) = UnmodeledUse : mu* +# 871| v871_6(void) = AliasedUse : ~mu871_3 +# 871| v871_7(void) = ExitFunction : + +# 883| void FuncPtrConversions(int(*)(int), void*) +# 883| Block 0 +# 883| v883_1(void) = EnterFunction : +# 883| mu883_2(unknown) = AliasedDefinition : +# 883| mu883_3(unknown) = UnmodeledDefinition : +# 883| r883_4(glval<..(*)(..)>) = VariableAddress[pfn] : +# 883| m883_5(..(*)(..)) = InitializeParameter[pfn] : &:r883_4 +# 883| r883_6(glval) = VariableAddress[p] : +# 883| m883_7(void *) = InitializeParameter[p] : &:r883_6 +# 883| r883_8(void *) = Load : &:r883_6, m883_7 +# 883| mu883_9(unknown) = InitializeIndirection[p] : &:r883_8 +# 884| r884_1(glval<..(*)(..)>) = VariableAddress[pfn] : +# 884| r884_2(..(*)(..)) = Load : &:r884_1, m883_5 +# 884| r884_3(void *) = Convert : r884_2 +# 884| r884_4(glval) = VariableAddress[p] : +# 884| m884_5(void *) = Store : &:r884_4, r884_3 +# 885| r885_1(glval) = VariableAddress[p] : +# 885| r885_2(void *) = Load : &:r885_1, m884_5 +# 885| r885_3(..(*)(..)) = Convert : r885_2 +# 885| r885_4(glval<..(*)(..)>) = VariableAddress[pfn] : +# 885| m885_5(..(*)(..)) = Store : &:r885_4, r885_3 +# 886| v886_1(void) = NoOp : +# 883| v883_10(void) = ReturnIndirection : &:r883_8, ~mu883_3 +# 883| v883_11(void) = ReturnVoid : +# 883| v883_12(void) = UnmodeledUse : mu* +# 883| v883_13(void) = AliasedUse : ~mu883_3 +# 883| v883_14(void) = ExitFunction : + +# 888| void VarArgUsage(int) +# 888| Block 0 +# 888| v888_1(void) = EnterFunction : +# 888| mu888_2(unknown) = AliasedDefinition : +# 888| mu888_3(unknown) = UnmodeledDefinition : +# 888| r888_4(glval) = VariableAddress[x] : +# 888| m888_5(int) = InitializeParameter[x] : &:r888_4 +# 889| r889_1(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 889| m889_2(__va_list_tag[1]) = Uninitialized[args] : &:r889_1 +# 891| r891_1(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 891| r891_2(__va_list_tag *) = Convert : r891_1 +# 891| r891_3(glval) = VariableAddress[x] : +# 891| v891_4(void) = VarArgsStart : 0:r891_2, 1:r891_3 +# 892| r892_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : +# 892| m892_2(__va_list_tag[1]) = Uninitialized[args2] : &:r892_1 +# 893| r893_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : +# 893| r893_2(__va_list_tag *) = Convert : r893_1 +# 893| r893_3(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 893| r893_4(__va_list_tag *) = Convert : r893_3 +# 893| v893_5(void) = VarArgsStart : 0:r893_2, 1:r893_4 +# 894| r894_1(glval) = VariableAddress[d] : +# 894| r894_2(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 894| r894_3(__va_list_tag *) = Convert : r894_2 +# 894| r894_4(glval) = VarArg : 0:r894_3 +# 894| r894_5(double) = Load : &:r894_4, ~mu888_3 +# 894| m894_6(double) = Store : &:r894_1, r894_5 +# 895| r895_1(glval) = VariableAddress[f] : +# 895| r895_2(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 895| r895_3(__va_list_tag *) = Convert : r895_2 +# 895| r895_4(glval) = VarArg : 0:r895_3 +# 895| r895_5(double) = Load : &:r895_4, ~mu888_3 +# 895| r895_6(float) = Convert : r895_5 +# 895| m895_7(float) = Store : &:r895_1, r895_6 +# 896| r896_1(glval<__va_list_tag[1]>) = VariableAddress[args] : +# 896| r896_2(__va_list_tag *) = Convert : r896_1 +# 896| v896_3(void) = VarArgsEnd : 0:r896_2 +# 897| r897_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : +# 897| r897_2(__va_list_tag *) = Convert : r897_1 +# 897| v897_3(void) = VarArgsEnd : 0:r897_2 +# 898| v898_1(void) = NoOp : +# 888| v888_6(void) = ReturnVoid : +# 888| v888_7(void) = UnmodeledUse : mu* +# 888| v888_8(void) = AliasedUse : ~mu888_3 +# 888| v888_9(void) = ExitFunction : + +# 900| void CastToVoid(int) +# 900| Block 0 +# 900| v900_1(void) = EnterFunction : +# 900| mu900_2(unknown) = AliasedDefinition : +# 900| mu900_3(unknown) = UnmodeledDefinition : +# 900| r900_4(glval) = VariableAddress[x] : +# 900| m900_5(int) = InitializeParameter[x] : &:r900_4 +# 901| r901_1(glval) = VariableAddress[x] : +# 901| v901_2(void) = Convert : r901_1 +# 902| v902_1(void) = NoOp : +# 900| v900_6(void) = ReturnVoid : +# 900| v900_7(void) = UnmodeledUse : mu* +# 900| v900_8(void) = AliasedUse : ~mu900_3 +# 900| v900_9(void) = ExitFunction : + +# 904| void ConstantConditions(int) +# 904| Block 0 +# 904| v904_1(void) = EnterFunction : +# 904| mu904_2(unknown) = AliasedDefinition : +# 904| mu904_3(unknown) = UnmodeledDefinition : +# 904| r904_4(glval) = VariableAddress[x] : +# 904| m904_5(int) = InitializeParameter[x] : &:r904_4 +# 905| r905_1(glval) = VariableAddress[a] : +# 905| r905_2(bool) = Constant[1] : +# 905| m905_3(bool) = Store : &:r905_1, r905_2 +# 906| r906_1(glval) = VariableAddress[b] : +# 906| r906_2(bool) = Constant[1] : +# 906| v906_3(void) = ConditionalBranch : r906_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 906| Block 1 +# 906| r906_4(glval) = VariableAddress[x] : +# 906| r906_5(int) = Load : &:r906_4, m904_5 +# 906| r906_6(glval) = VariableAddress[#temp906:11] : +# 906| m906_7(int) = Store : &:r906_6, r906_5 +# 906| r906_8(glval) = VariableAddress[#temp906:11] : +# 906| r906_9(int) = Load : &:r906_8, m906_7 +# 906| m906_10(int) = Store : &:r906_1, r906_9 +# 907| v907_1(void) = NoOp : +# 904| v904_6(void) = ReturnVoid : +# 904| v904_7(void) = UnmodeledUse : mu* +# 904| v904_8(void) = AliasedUse : ~mu904_3 +# 904| v904_9(void) = ExitFunction : + +# 904| Block 2 +# 904| v904_10(void) = Unreached : + +# 940| void OperatorNew() +# 940| Block 0 +# 940| v940_1(void) = EnterFunction : +# 940| mu940_2(unknown) = AliasedDefinition : +# 940| mu940_3(unknown) = UnmodeledDefinition : +# 941| r941_1(glval) = FunctionAddress[operator new] : +# 941| r941_2(unsigned long) = Constant[4] : +# 941| r941_3(void *) = Call : func:r941_1, 0:r941_2 +# 941| mu941_4(unknown) = ^CallSideEffect : ~mu940_3 +# 941| r941_5(int *) = Convert : r941_3 +# 942| r942_1(glval) = FunctionAddress[operator new] : +# 942| r942_2(unsigned long) = Constant[4] : +# 942| r942_3(float) = Constant[1.0] : +# 942| r942_4(void *) = Call : func:r942_1, 0:r942_2, 1:r942_3 +# 942| mu942_5(unknown) = ^CallSideEffect : ~mu940_3 +# 942| r942_6(int *) = Convert : r942_4 +# 943| r943_1(glval) = FunctionAddress[operator new] : +# 943| r943_2(unsigned long) = Constant[4] : +# 943| r943_3(void *) = Call : func:r943_1, 0:r943_2 +# 943| mu943_4(unknown) = ^CallSideEffect : ~mu940_3 +# 943| r943_5(int *) = Convert : r943_3 +# 943| r943_6(int) = Constant[0] : +# 943| mu943_7(int) = Store : &:r943_5, r943_6 +# 944| r944_1(glval) = FunctionAddress[operator new] : +# 944| r944_2(unsigned long) = Constant[8] : +# 944| r944_3(void *) = Call : func:r944_1, 0:r944_2 +# 944| mu944_4(unknown) = ^CallSideEffect : ~mu940_3 +# 944| r944_5(String *) = Convert : r944_3 +# 944| r944_6(glval) = FunctionAddress[String] : +# 944| v944_7(void) = Call : func:r944_6, this:r944_5 +# 944| mu944_8(unknown) = ^CallSideEffect : ~mu940_3 +# 944| mu944_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r944_5 +# 945| r945_1(glval) = FunctionAddress[operator new] : +# 945| r945_2(unsigned long) = Constant[8] : +# 945| r945_3(float) = Constant[1.0] : +# 945| r945_4(void *) = Call : func:r945_1, 0:r945_2, 1:r945_3 +# 945| mu945_5(unknown) = ^CallSideEffect : ~mu940_3 +# 945| r945_6(String *) = Convert : r945_4 +# 945| r945_7(glval) = FunctionAddress[String] : +# 945| r945_8(glval) = StringConstant["hello"] : +# 945| r945_9(char *) = Convert : r945_8 +# 945| v945_10(void) = Call : func:r945_7, this:r945_6, 0:r945_9 +# 945| mu945_11(unknown) = ^CallSideEffect : ~mu940_3 +# 945| mu945_12(String) = ^IndirectMayWriteSideEffect[-1] : &:r945_6 +# 945| v945_13(void) = ^BufferReadSideEffect[0] : &:r945_9, ~mu940_3 +# 945| mu945_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r945_9 +# 946| r946_1(glval) = FunctionAddress[operator new] : +# 946| r946_2(unsigned long) = Constant[256] : +# 946| r946_3(align_val_t) = Constant[128] : +# 946| r946_4(void *) = Call : func:r946_1, 0:r946_2, 1:r946_3 +# 946| mu946_5(unknown) = ^CallSideEffect : ~mu940_3 +# 946| r946_6(Overaligned *) = Convert : r946_4 +# 947| r947_1(glval) = FunctionAddress[operator new] : +# 947| r947_2(unsigned long) = Constant[256] : +# 947| r947_3(align_val_t) = Constant[128] : +# 947| r947_4(float) = Constant[1.0] : +# 947| r947_5(void *) = Call : func:r947_1, 0:r947_2, 1:r947_3, 2:r947_4 +# 947| mu947_6(unknown) = ^CallSideEffect : ~mu940_3 +# 947| r947_7(Overaligned *) = Convert : r947_5 +# 947| r947_8(Overaligned) = Constant[0] : +# 947| mu947_9(Overaligned) = Store : &:r947_7, r947_8 +# 948| v948_1(void) = NoOp : +# 940| v940_4(void) = ReturnVoid : +# 940| v940_5(void) = UnmodeledUse : mu* +# 940| v940_6(void) = AliasedUse : ~mu940_3 +# 940| v940_7(void) = ExitFunction : + +# 950| void OperatorNewArray(int) +# 950| Block 0 +# 950| v950_1(void) = EnterFunction : +# 950| mu950_2(unknown) = AliasedDefinition : +# 950| mu950_3(unknown) = UnmodeledDefinition : +# 950| r950_4(glval) = VariableAddress[n] : +# 950| m950_5(int) = InitializeParameter[n] : &:r950_4 +# 951| r951_1(glval) = FunctionAddress[operator new[]] : +# 951| r951_2(unsigned long) = Constant[40] : +# 951| r951_3(void *) = Call : func:r951_1, 0:r951_2 +# 951| mu951_4(unknown) = ^CallSideEffect : ~mu950_3 +# 951| r951_5(int *) = Convert : r951_3 +# 952| r952_1(glval) = FunctionAddress[operator new[]] : +# 952| r952_2(glval) = VariableAddress[n] : +# 952| r952_3(int) = Load : &:r952_2, m950_5 +# 952| r952_4(unsigned long) = Convert : r952_3 +# 952| r952_5(unsigned long) = Constant[4] : +# 952| r952_6(unsigned long) = Mul : r952_4, r952_5 +# 952| r952_7(void *) = Call : func:r952_1, 0:r952_6 +# 952| mu952_8(unknown) = ^CallSideEffect : ~mu950_3 +# 952| r952_9(int *) = Convert : r952_7 +# 953| r953_1(glval) = FunctionAddress[operator new[]] : +# 953| r953_2(glval) = VariableAddress[n] : +# 953| r953_3(int) = Load : &:r953_2, m950_5 +# 953| r953_4(unsigned long) = Convert : r953_3 +# 953| r953_5(unsigned long) = Constant[4] : +# 953| r953_6(unsigned long) = Mul : r953_4, r953_5 +# 953| r953_7(float) = Constant[1.0] : +# 953| r953_8(void *) = Call : func:r953_1, 0:r953_6, 1:r953_7 +# 953| mu953_9(unknown) = ^CallSideEffect : ~mu950_3 +# 953| r953_10(int *) = Convert : r953_8 +# 954| r954_1(glval) = FunctionAddress[operator new[]] : +# 954| r954_2(glval) = VariableAddress[n] : +# 954| r954_3(int) = Load : &:r954_2, m950_5 +# 954| r954_4(unsigned long) = Convert : r954_3 +# 954| r954_5(unsigned long) = Constant[8] : +# 954| r954_6(unsigned long) = Mul : r954_4, r954_5 +# 954| r954_7(void *) = Call : func:r954_1, 0:r954_6 +# 954| mu954_8(unknown) = ^CallSideEffect : ~mu950_3 +# 954| r954_9(String *) = Convert : r954_7 +# 955| r955_1(glval) = FunctionAddress[operator new[]] : +# 955| r955_2(glval) = VariableAddress[n] : +# 955| r955_3(int) = Load : &:r955_2, m950_5 +# 955| r955_4(unsigned long) = Convert : r955_3 +# 955| r955_5(unsigned long) = Constant[256] : +# 955| r955_6(unsigned long) = Mul : r955_4, r955_5 +# 955| r955_7(align_val_t) = Constant[128] : +# 955| r955_8(void *) = Call : func:r955_1, 0:r955_6, 1:r955_7 +# 955| mu955_9(unknown) = ^CallSideEffect : ~mu950_3 +# 955| r955_10(Overaligned *) = Convert : r955_8 +# 956| r956_1(glval) = FunctionAddress[operator new[]] : +# 956| r956_2(unsigned long) = Constant[2560] : +# 956| r956_3(align_val_t) = Constant[128] : +# 956| r956_4(float) = Constant[1.0] : +# 956| r956_5(void *) = Call : func:r956_1, 0:r956_2, 1:r956_3, 2:r956_4 +# 956| mu956_6(unknown) = ^CallSideEffect : ~mu950_3 +# 956| r956_7(Overaligned *) = Convert : r956_5 +# 957| r957_1(glval) = FunctionAddress[operator new[]] : +# 957| r957_2(glval) = VariableAddress[n] : +# 957| r957_3(int) = Load : &:r957_2, m950_5 +# 957| r957_4(unsigned long) = Convert : r957_3 +# 957| r957_5(unsigned long) = Constant[1] : +# 957| r957_6(unsigned long) = Mul : r957_4, r957_5 +# 957| r957_7(void *) = Call : func:r957_1, 0:r957_6 +# 957| mu957_8(unknown) = ^CallSideEffect : ~mu950_3 +# 957| r957_9(DefaultCtorWithDefaultParam *) = Convert : r957_7 +# 958| r958_1(glval) = FunctionAddress[operator new[]] : +# 958| r958_2(glval) = VariableAddress[n] : +# 958| r958_3(int) = Load : &:r958_2, m950_5 +# 958| r958_4(unsigned long) = Convert : r958_3 +# 958| r958_5(unsigned long) = Constant[4] : +# 958| r958_6(unsigned long) = Mul : r958_4, r958_5 +# 958| r958_7(void *) = Call : func:r958_1, 0:r958_6 +# 958| mu958_8(unknown) = ^CallSideEffect : ~mu950_3 +# 958| r958_9(int *) = Convert : r958_7 +# 959| v959_1(void) = NoOp : +# 950| v950_6(void) = ReturnVoid : +# 950| v950_7(void) = UnmodeledUse : mu* +# 950| v950_8(void) = AliasedUse : ~mu950_3 +# 950| v950_9(void) = ExitFunction : + +# 961| int designatedInit() +# 961| Block 0 +# 961| v961_1(void) = EnterFunction : +# 961| mu961_2(unknown) = AliasedDefinition : +# 961| mu961_3(unknown) = UnmodeledDefinition : +# 962| r962_1(glval) = VariableAddress[a1] : +# 962| mu962_2(int[1000]) = Uninitialized[a1] : &:r962_1 +# 962| r962_3(int) = Constant[0] : +# 962| r962_4(glval) = PointerAdd[4] : r962_1, r962_3 +# 962| r962_5(unknown[8]) = Constant[0] : +# 962| mu962_6(unknown[8]) = Store : &:r962_4, r962_5 +# 962| r962_7(int) = Constant[2] : +# 962| r962_8(glval) = PointerAdd[4] : r962_1, r962_7 +# 962| r962_9(int) = Constant[10002] : +# 962| mu962_10(int) = Store : &:r962_8, r962_9 +# 962| r962_11(int) = Constant[3] : +# 962| r962_12(glval) = PointerAdd[4] : r962_1, r962_11 +# 962| r962_13(unknown[3588]) = Constant[0] : +# 962| mu962_14(unknown[3588]) = Store : &:r962_12, r962_13 +# 962| r962_15(int) = Constant[900] : +# 962| r962_16(glval) = PointerAdd[4] : r962_1, r962_15 +# 962| r962_17(int) = Constant[10900] : +# 962| mu962_18(int) = Store : &:r962_16, r962_17 +# 962| r962_19(int) = Constant[901] : +# 962| r962_20(glval) = PointerAdd[4] : r962_1, r962_19 +# 962| r962_21(unknown[396]) = Constant[0] : +# 962| mu962_22(unknown[396]) = Store : &:r962_20, r962_21 +# 963| r963_1(glval) = VariableAddress[#return] : +# 963| r963_2(glval) = VariableAddress[a1] : +# 963| r963_3(int *) = Convert : r963_2 +# 963| r963_4(int) = Constant[900] : +# 963| r963_5(glval) = PointerAdd[4] : r963_3, r963_4 +# 963| r963_6(int) = Load : &:r963_5, ~mu961_3 +# 963| m963_7(int) = Store : &:r963_1, r963_6 +# 961| r961_4(glval) = VariableAddress[#return] : +# 961| v961_5(void) = ReturnValue : &:r961_4, m963_7 +# 961| v961_6(void) = UnmodeledUse : mu* +# 961| v961_7(void) = AliasedUse : ~mu961_3 +# 961| v961_8(void) = ExitFunction : + +# 966| void IfStmtWithDeclaration(int, int) +# 966| Block 0 +# 966| v966_1(void) = EnterFunction : +# 966| mu966_2(unknown) = AliasedDefinition : +# 966| mu966_3(unknown) = UnmodeledDefinition : +# 966| r966_4(glval) = VariableAddress[x] : +# 966| m966_5(int) = InitializeParameter[x] : &:r966_4 +# 966| r966_6(glval) = VariableAddress[y] : +# 966| m966_7(int) = InitializeParameter[y] : &:r966_6 +# 967| r967_1(glval) = VariableAddress[b] : +# 967| r967_2(glval) = VariableAddress[x] : +# 967| r967_3(int) = Load : &:r967_2, m966_5 +# 967| r967_4(glval) = VariableAddress[y] : +# 967| r967_5(int) = Load : &:r967_4, m966_7 +# 967| r967_6(bool) = CompareLT : r967_3, r967_5 +# 967| m967_7(bool) = Store : &:r967_1, r967_6 +# 967| r967_8(glval) = VariableAddress[b] : +# 967| r967_9(bool) = Load : &:r967_8, m967_7 +# 967| r967_10(bool) = CopyValue : r967_9 +# 967| v967_11(void) = ConditionalBranch : r967_10 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 968| Block 1 +# 968| r968_1(int) = Constant[5] : +# 968| r968_2(glval) = VariableAddress[x] : +# 968| m968_3(int) = Store : &:r968_2, r968_1 +#-----| Goto -> Block 6 + +# 970| Block 2 +# 970| r970_1(glval) = VariableAddress[z] : +# 970| r970_2(glval) = VariableAddress[x] : +# 970| r970_3(int) = Load : &:r970_2, m966_5 +# 970| r970_4(glval) = VariableAddress[y] : +# 970| r970_5(int) = Load : &:r970_4, m966_7 +# 970| r970_6(int) = Add : r970_3, r970_5 +# 970| m970_7(int) = Store : &:r970_1, r970_6 +# 970| r970_8(glval) = VariableAddress[z] : +# 970| r970_9(int) = Load : &:r970_8, m970_7 +# 970| r970_10(int) = Constant[0] : +# 970| r970_11(bool) = CompareNE : r970_9, r970_10 +# 970| r970_12(bool) = CopyValue : r970_11 +# 970| v970_13(void) = ConditionalBranch : r970_12 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 971| Block 3 +# 971| r971_1(int) = Constant[7] : +# 971| r971_2(glval) = VariableAddress[y] : +# 971| m971_3(int) = Store : &:r971_2, r971_1 +#-----| Goto -> Block 6 + +# 973| Block 4 +# 973| r973_1(glval) = VariableAddress[p] : +# 973| r973_2(glval) = VariableAddress[x] : +# 973| r973_3(int *) = CopyValue : r973_2 +# 973| m973_4(int *) = Store : &:r973_1, r973_3 +# 973| r973_5(glval) = VariableAddress[p] : +# 973| r973_6(int *) = Load : &:r973_5, m973_4 +# 973| r973_7(int *) = Constant[0] : +# 973| r973_8(bool) = CompareNE : r973_6, r973_7 +# 973| r973_9(bool) = CopyValue : r973_8 +# 973| v973_10(void) = ConditionalBranch : r973_9 +#-----| False -> Block 6 +#-----| True -> Block 5 + +# 974| Block 5 +# 974| r974_1(int) = Constant[2] : +# 974| r974_2(glval) = VariableAddress[p] : +# 974| r974_3(int *) = Load : &:r974_2, m973_4 +# 974| r974_4(glval) = CopyValue : r974_3 +# 974| mu974_5(int) = Store : &:r974_4, r974_1 +#-----| Goto -> Block 6 + +# 976| Block 6 +# 976| v976_1(void) = NoOp : +# 966| v966_8(void) = ReturnVoid : +# 966| v966_9(void) = UnmodeledUse : mu* +# 966| v966_10(void) = AliasedUse : ~mu966_3 +# 966| v966_11(void) = ExitFunction : + +# 978| void WhileStmtWithDeclaration(int, int) +# 978| Block 0 +# 978| v978_1(void) = EnterFunction : +# 978| mu978_2(unknown) = AliasedDefinition : +# 978| mu978_3(unknown) = UnmodeledDefinition : +# 978| r978_4(glval) = VariableAddress[x] : +# 978| m978_5(int) = InitializeParameter[x] : &:r978_4 +# 978| r978_6(glval) = VariableAddress[y] : +# 978| m978_7(int) = InitializeParameter[y] : &:r978_6 +#-----| Goto -> Block 7 + +# 979| Block 1 +# 979| v979_1(void) = NoOp : +#-----| Goto (back edge) -> Block 7 + +# 981| Block 2 +# 981| r981_1(glval) = VariableAddress[z] : +# 981| r981_2(glval) = VariableAddress[x] : +# 981| r981_3(int) = Load : &:r981_2, m978_5 +# 981| r981_4(glval) = VariableAddress[y] : +# 981| r981_5(int) = Load : &:r981_4, m978_7 +# 981| r981_6(int) = Add : r981_3, r981_5 +# 981| m981_7(int) = Store : &:r981_1, r981_6 +# 981| r981_8(glval) = VariableAddress[z] : +# 981| r981_9(int) = Load : &:r981_8, m981_7 +# 981| r981_10(int) = Constant[0] : +# 981| r981_11(bool) = CompareNE : r981_9, r981_10 +# 981| r981_12(bool) = CopyValue : r981_11 +# 981| v981_13(void) = ConditionalBranch : r981_12 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 981| Block 3 +# 981| v981_14(void) = NoOp : +#-----| Goto (back edge) -> Block 2 + +# 983| Block 4 +# 983| r983_1(glval) = VariableAddress[p] : +# 983| r983_2(glval) = VariableAddress[x] : +# 983| r983_3(int *) = CopyValue : r983_2 +# 983| m983_4(int *) = Store : &:r983_1, r983_3 +# 983| r983_5(glval) = VariableAddress[p] : +# 983| r983_6(int *) = Load : &:r983_5, m983_4 +# 983| r983_7(int *) = Constant[0] : +# 983| r983_8(bool) = CompareNE : r983_6, r983_7 +# 983| r983_9(bool) = CopyValue : r983_8 +# 983| v983_10(void) = ConditionalBranch : r983_9 +#-----| False -> Block 6 +#-----| True -> Block 5 + +# 983| Block 5 +# 983| v983_11(void) = NoOp : +#-----| Goto (back edge) -> Block 4 + +# 985| Block 6 +# 985| v985_1(void) = NoOp : +# 978| v978_8(void) = ReturnVoid : +# 978| v978_9(void) = UnmodeledUse : mu* +# 978| v978_10(void) = AliasedUse : ~mu978_3 +# 978| v978_11(void) = ExitFunction : + +# 979| Block 7 +# 979| r979_2(glval) = VariableAddress[b] : +# 979| r979_3(glval) = VariableAddress[x] : +# 979| r979_4(int) = Load : &:r979_3, m978_5 +# 979| r979_5(glval) = VariableAddress[y] : +# 979| r979_6(int) = Load : &:r979_5, m978_7 +# 979| r979_7(bool) = CompareLT : r979_4, r979_6 +# 979| m979_8(bool) = Store : &:r979_2, r979_7 +# 979| r979_9(glval) = VariableAddress[b] : +# 979| r979_10(bool) = Load : &:r979_9, m979_8 +# 979| r979_11(bool) = CopyValue : r979_10 +# 979| v979_12(void) = ConditionalBranch : r979_11 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 987| int PointerDecay(int[], int(float)) +# 987| Block 0 +# 987| v987_1(void) = EnterFunction : +# 987| mu987_2(unknown) = AliasedDefinition : +# 987| mu987_3(unknown) = UnmodeledDefinition : +# 987| r987_4(glval) = VariableAddress[a] : +# 987| m987_5(int *) = InitializeParameter[a] : &:r987_4 +# 987| r987_6(int *) = Load : &:r987_4, m987_5 +# 987| mu987_7(unknown) = InitializeIndirection[a] : &:r987_6 +# 987| r987_8(glval<..(*)(..)>) = VariableAddress[fn] : +# 987| m987_9(..(*)(..)) = InitializeParameter[fn] : &:r987_8 +# 988| r988_1(glval) = VariableAddress[#return] : +# 988| r988_2(glval) = VariableAddress[a] : +# 988| r988_3(int *) = Load : &:r988_2, m987_5 +# 988| r988_4(int) = Constant[0] : +# 988| r988_5(glval) = PointerAdd[4] : r988_3, r988_4 +# 988| r988_6(int) = Load : &:r988_5, ~mu987_3 +# 988| r988_7(glval<..(*)(..)>) = VariableAddress[fn] : +# 988| r988_8(..(*)(..)) = Load : &:r988_7, m987_9 +# 988| r988_9(float) = Constant[1.0] : +# 988| r988_10(int) = Call : func:r988_8, 0:r988_9 +# 988| mu988_11(unknown) = ^CallSideEffect : ~mu987_3 +# 988| r988_12(int) = Add : r988_6, r988_10 +# 988| m988_13(int) = Store : &:r988_1, r988_12 +# 987| v987_10(void) = ReturnIndirection : &:r987_6, ~mu987_3 +# 987| r987_11(glval) = VariableAddress[#return] : +# 987| v987_12(void) = ReturnValue : &:r987_11, m988_13 +# 987| v987_13(void) = UnmodeledUse : mu* +# 987| v987_14(void) = AliasedUse : ~mu987_3 +# 987| v987_15(void) = ExitFunction : + +# 991| int ExprStmt(int, int, int) +# 991| Block 0 +# 991| v991_1(void) = EnterFunction : +# 991| mu991_2(unknown) = AliasedDefinition : +# 991| mu991_3(unknown) = UnmodeledDefinition : +# 991| r991_4(glval) = VariableAddress[b] : +# 991| m991_5(int) = InitializeParameter[b] : &:r991_4 +# 991| r991_6(glval) = VariableAddress[y] : +# 991| m991_7(int) = InitializeParameter[y] : &:r991_6 +# 991| r991_8(glval) = VariableAddress[z] : +# 991| m991_9(int) = InitializeParameter[z] : &:r991_8 +# 992| r992_1(glval) = VariableAddress[x] : +# 993| r993_1(glval) = VariableAddress[w] : +# 993| m993_2(int) = Uninitialized[w] : &:r993_1 +# 994| r994_1(glval) = VariableAddress[b] : +# 994| r994_2(int) = Load : &:r994_1, m991_5 +# 994| r994_3(int) = Constant[0] : +# 994| r994_4(bool) = CompareNE : r994_2, r994_3 +# 994| v994_5(void) = ConditionalBranch : r994_4 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 995| Block 1 +# 995| r995_1(glval) = VariableAddress[y] : +# 995| r995_2(int) = Load : &:r995_1, m991_7 +# 995| r995_3(glval) = VariableAddress[w] : +# 995| m995_4(int) = Store : &:r995_3, r995_2 +#-----| Goto -> Block 3 + +# 997| Block 2 +# 997| r997_1(glval) = VariableAddress[z] : +# 997| r997_2(int) = Load : &:r997_1, m991_9 +# 997| r997_3(glval) = VariableAddress[w] : +# 997| m997_4(int) = Store : &:r997_3, r997_2 +#-----| Goto -> Block 3 + +# 999| Block 3 +# 999| m999_1(int) = Phi : from 1:m995_4, from 2:m997_4 +# 999| r999_2(glval) = VariableAddress[w] : +# 999| r999_3(int) = Load : &:r999_2, m999_1 +# 992| r992_2(int) = CopyValue : r999_3 +# 992| m992_3(int) = Store : &:r992_1, r992_2 +# 1002| r1002_1(glval) = VariableAddress[#return] : +# 1002| r1002_2(glval) = VariableAddress[x] : +# 1002| r1002_3(int) = Load : &:r1002_2, m992_3 +# 1002| r1002_4(int) = CopyValue : r1002_3 +# 1002| m1002_5(int) = Store : &:r1002_1, r1002_4 +# 991| r991_10(glval) = VariableAddress[#return] : +# 991| v991_11(void) = ReturnValue : &:r991_10, m1002_5 +# 991| v991_12(void) = UnmodeledUse : mu* +# 991| v991_13(void) = AliasedUse : ~mu991_3 +# 991| v991_14(void) = ExitFunction : + +# 1006| void OperatorDelete() +# 1006| Block 0 +# 1006| v1006_1(void) = EnterFunction : +# 1006| mu1006_2(unknown) = AliasedDefinition : +# 1006| mu1006_3(unknown) = UnmodeledDefinition : +# 1007| r1007_1(int *) = Constant[0] : +# 1007| v1007_2(void) = NoOp : +# 1008| r1008_1(String *) = Constant[0] : +# 1008| v1008_2(void) = NoOp : +# 1009| r1009_1(SizedDealloc *) = Constant[0] : +# 1009| v1009_2(void) = NoOp : +# 1010| r1010_1(Overaligned *) = Constant[0] : +# 1010| v1010_2(void) = NoOp : +# 1011| r1011_1(PolymorphicBase *) = Constant[0] : +# 1011| v1011_2(void) = NoOp : +# 1012| v1012_1(void) = NoOp : +# 1006| v1006_4(void) = ReturnVoid : +# 1006| v1006_5(void) = UnmodeledUse : mu* +# 1006| v1006_6(void) = AliasedUse : ~mu1006_3 +# 1006| v1006_7(void) = ExitFunction : + +# 1015| void OperatorDeleteArray() +# 1015| Block 0 +# 1015| v1015_1(void) = EnterFunction : +# 1015| mu1015_2(unknown) = AliasedDefinition : +# 1015| mu1015_3(unknown) = UnmodeledDefinition : +# 1016| r1016_1(int *) = Constant[0] : +# 1016| v1016_2(void) = NoOp : +# 1017| r1017_1(String *) = Constant[0] : +# 1017| v1017_2(void) = NoOp : +# 1018| r1018_1(SizedDealloc *) = Constant[0] : +# 1018| v1018_2(void) = NoOp : +# 1019| r1019_1(Overaligned *) = Constant[0] : +# 1019| v1019_2(void) = NoOp : +# 1020| r1020_1(PolymorphicBase *) = Constant[0] : +# 1020| v1020_2(void) = NoOp : +# 1021| v1021_1(void) = NoOp : +# 1015| v1015_4(void) = ReturnVoid : +# 1015| v1015_5(void) = UnmodeledUse : mu* +# 1015| v1015_6(void) = AliasedUse : ~mu1015_3 +# 1015| v1015_7(void) = ExitFunction : + +# 1025| void EmptyStructInit() +# 1025| Block 0 +# 1025| v1025_1(void) = EnterFunction : +# 1025| mu1025_2(unknown) = AliasedDefinition : +# 1025| mu1025_3(unknown) = UnmodeledDefinition : +# 1026| r1026_1(glval) = VariableAddress[s] : +# 1026| m1026_2(EmptyStruct) = Uninitialized[s] : &:r1026_1 +# 1027| v1027_1(void) = NoOp : +# 1025| v1025_4(void) = ReturnVoid : +# 1025| v1025_5(void) = UnmodeledUse : mu* +# 1025| v1025_6(void) = AliasedUse : ~mu1025_3 +# 1025| v1025_7(void) = ExitFunction : + +# 1029| void (lambda [] type at line 1029, col. 12)::operator()() const +# 1029| Block 0 +# 1029| v1029_1(void) = EnterFunction : +# 1029| mu1029_2(unknown) = AliasedDefinition : +# 1029| mu1029_3(unknown) = UnmodeledDefinition : +# 1029| r1029_4(glval) = InitializeThis : +# 1029| v1029_5(void) = NoOp : +# 1029| v1029_6(void) = ReturnVoid : +# 1029| v1029_7(void) = UnmodeledUse : mu* +# 1029| v1029_8(void) = AliasedUse : ~mu1029_3 +# 1029| v1029_9(void) = ExitFunction : + +# 1029| void(* (lambda [] type at line 1029, col. 12)::operator void (*)()() const)() +# 1029| Block 0 +# 1029| v1029_1(void) = EnterFunction : +# 1029| mu1029_2(unknown) = AliasedDefinition : +# 1029| mu1029_3(unknown) = UnmodeledDefinition : +# 1029| r1029_4(glval) = InitializeThis : +# 1029| r1029_5(glval<..(*)(..)>) = VariableAddress[#return] : +# 1029| r1029_6(..(*)(..)) = FunctionAddress[_FUN] : +# 1029| m1029_7(..(*)(..)) = Store : &:r1029_5, r1029_6 +# 1029| r1029_8(glval<..(*)(..)>) = VariableAddress[#return] : +# 1029| v1029_9(void) = ReturnValue : &:r1029_8, m1029_7 +# 1029| v1029_10(void) = UnmodeledUse : mu* +# 1029| v1029_11(void) = AliasedUse : ~mu1029_3 +# 1029| v1029_12(void) = ExitFunction : + +# 1031| void Lambda(int, String const&) +# 1031| Block 0 +# 1031| v1031_1(void) = EnterFunction : +# 1031| mu1031_2(unknown) = AliasedDefinition : +# 1031| mu1031_3(unknown) = UnmodeledDefinition : +# 1031| r1031_4(glval) = VariableAddress[x] : +# 1031| m1031_5(int) = InitializeParameter[x] : &:r1031_4 +# 1031| r1031_6(glval) = VariableAddress[s] : +# 1031| m1031_7(String &) = InitializeParameter[s] : &:r1031_6 +# 1031| r1031_8(String &) = Load : &:r1031_6, m1031_7 +# 1031| mu1031_9(unknown) = InitializeIndirection[s] : &:r1031_8 +# 1032| r1032_1(glval) = VariableAddress[lambda_empty] : +# 1032| r1032_2(glval) = VariableAddress[#temp1032:23] : +# 1032| m1032_3(decltype([...](...){...})) = Uninitialized[#temp1032:23] : &:r1032_2 +# 1032| r1032_4(decltype([...](...){...})) = Load : &:r1032_2, m1032_3 +# 1032| m1032_5(decltype([...](...){...})) = Store : &:r1032_1, r1032_4 +# 1033| r1033_1(char) = Constant[65] : +# 1034| r1034_1(glval) = VariableAddress[lambda_ref] : +# 1034| r1034_2(glval) = VariableAddress[#temp1034:20] : +# 1034| mu1034_3(decltype([...](...){...})) = Uninitialized[#temp1034:20] : &:r1034_2 +# 1034| r1034_4(glval) = FieldAddress[s] : r1034_2 +#-----| r0_1(glval) = VariableAddress[s] : +#-----| r0_2(String &) = Load : &:r0_1, m1031_7 +# 1034| r1034_5(glval) = CopyValue : r0_2 +# 1034| r1034_6(String &) = CopyValue : r1034_5 +# 1034| mu1034_7(String &) = Store : &:r1034_4, r1034_6 +# 1034| r1034_8(glval) = FieldAddress[x] : r1034_2 +#-----| r0_3(glval) = VariableAddress[x] : +#-----| r0_4(int &) = CopyValue : r0_3 +#-----| mu0_5(int &) = Store : &:r1034_8, r0_4 +# 1034| r1034_9(decltype([...](...){...})) = Load : &:r1034_2, ~mu1031_3 +# 1034| mu1034_10(decltype([...](...){...})) = Store : &:r1034_1, r1034_9 +# 1035| r1035_1(glval) = VariableAddress[lambda_ref] : +# 1035| r1035_2(glval) = Convert : r1035_1 +# 1035| r1035_3(glval) = FunctionAddress[operator()] : +# 1035| r1035_4(float) = Constant[1.0] : +# 1035| r1035_5(char) = Call : func:r1035_3, this:r1035_2, 0:r1035_4 +# 1035| mu1035_6(unknown) = ^CallSideEffect : ~mu1031_3 +# 1035| v1035_7(void) = ^BufferReadSideEffect[-1] : &:r1035_2, ~mu1031_3 +# 1035| mu1035_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1035_2 +# 1036| r1036_1(glval) = VariableAddress[lambda_val] : +# 1036| r1036_2(glval) = VariableAddress[#temp1036:20] : +# 1036| mu1036_3(decltype([...](...){...})) = Uninitialized[#temp1036:20] : &:r1036_2 +# 1036| r1036_4(glval) = FieldAddress[s] : r1036_2 +#-----| r0_6(glval) = FunctionAddress[String] : +#-----| v0_7(void) = Call : func:r0_6, this:r1036_4 +#-----| mu0_8(unknown) = ^CallSideEffect : ~mu1031_3 +#-----| mu0_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r1036_4 +# 1036| r1036_5(glval) = FieldAddress[x] : r1036_2 +#-----| r0_10(glval) = VariableAddress[x] : +#-----| r0_11(int) = Load : &:r0_10, m1031_5 +#-----| mu0_12(int) = Store : &:r1036_5, r0_11 +# 1036| r1036_6(decltype([...](...){...})) = Load : &:r1036_2, ~mu1031_3 +# 1036| mu1036_7(decltype([...](...){...})) = Store : &:r1036_1, r1036_6 +# 1037| r1037_1(glval) = VariableAddress[lambda_val] : +# 1037| r1037_2(glval) = Convert : r1037_1 +# 1037| r1037_3(glval) = FunctionAddress[operator()] : +# 1037| r1037_4(float) = Constant[2.0] : +# 1037| r1037_5(char) = Call : func:r1037_3, this:r1037_2, 0:r1037_4 +# 1037| mu1037_6(unknown) = ^CallSideEffect : ~mu1031_3 +# 1037| v1037_7(void) = ^BufferReadSideEffect[-1] : &:r1037_2, ~mu1031_3 +# 1037| mu1037_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1037_2 +# 1038| r1038_1(glval) = VariableAddress[lambda_ref_explicit] : +# 1038| r1038_2(glval) = VariableAddress[#temp1038:29] : +# 1038| mu1038_3(decltype([...](...){...})) = Uninitialized[#temp1038:29] : &:r1038_2 +# 1038| r1038_4(glval) = FieldAddress[s] : r1038_2 +# 1038| r1038_5(glval) = VariableAddress[s] : +# 1038| r1038_6(String &) = Load : &:r1038_5, m1031_7 +# 1038| r1038_7(glval) = CopyValue : r1038_6 +# 1038| r1038_8(String &) = CopyValue : r1038_7 +# 1038| mu1038_9(String &) = Store : &:r1038_4, r1038_8 +# 1038| r1038_10(decltype([...](...){...})) = Load : &:r1038_2, ~mu1031_3 +# 1038| mu1038_11(decltype([...](...){...})) = Store : &:r1038_1, r1038_10 +# 1039| r1039_1(glval) = VariableAddress[lambda_ref_explicit] : +# 1039| r1039_2(glval) = Convert : r1039_1 +# 1039| r1039_3(glval) = FunctionAddress[operator()] : +# 1039| r1039_4(float) = Constant[3.0] : +# 1039| r1039_5(char) = Call : func:r1039_3, this:r1039_2, 0:r1039_4 +# 1039| mu1039_6(unknown) = ^CallSideEffect : ~mu1031_3 +# 1039| v1039_7(void) = ^BufferReadSideEffect[-1] : &:r1039_2, ~mu1031_3 +# 1039| mu1039_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1039_2 +# 1040| r1040_1(glval) = VariableAddress[lambda_val_explicit] : +# 1040| r1040_2(glval) = VariableAddress[#temp1040:29] : +# 1040| m1040_3(decltype([...](...){...})) = Uninitialized[#temp1040:29] : &:r1040_2 +# 1040| r1040_4(glval) = FieldAddress[s] : r1040_2 +#-----| r0_13(glval) = FunctionAddress[String] : +#-----| v0_14(void) = Call : func:r0_13, this:r1040_4 +#-----| mu0_15(unknown) = ^CallSideEffect : ~mu1031_3 +#-----| m0_16(String) = ^IndirectMayWriteSideEffect[-1] : &:r1040_4 +# 1040| r1040_5(decltype([...](...){...})) = Load : &:r1040_2, m0_16 +# 1040| mu1040_6(decltype([...](...){...})) = Store : &:r1040_1, r1040_5 +# 1041| r1041_1(glval) = VariableAddress[lambda_val_explicit] : +# 1041| r1041_2(glval) = Convert : r1041_1 +# 1041| r1041_3(glval) = FunctionAddress[operator()] : +# 1041| r1041_4(float) = Constant[4.0] : +# 1041| r1041_5(char) = Call : func:r1041_3, this:r1041_2, 0:r1041_4 +# 1041| mu1041_6(unknown) = ^CallSideEffect : ~mu1031_3 +# 1041| v1041_7(void) = ^BufferReadSideEffect[-1] : &:r1041_2, ~mu1031_3 +# 1041| mu1041_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1041_2 +# 1042| r1042_1(glval) = VariableAddress[lambda_mixed_explicit] : +# 1042| r1042_2(glval) = VariableAddress[#temp1042:31] : +# 1042| mu1042_3(decltype([...](...){...})) = Uninitialized[#temp1042:31] : &:r1042_2 +# 1042| r1042_4(glval) = FieldAddress[s] : r1042_2 +# 1042| r1042_5(glval) = VariableAddress[s] : +# 1042| r1042_6(String &) = Load : &:r1042_5, m1031_7 +# 1042| r1042_7(glval) = CopyValue : r1042_6 +# 1042| r1042_8(String &) = CopyValue : r1042_7 +# 1042| mu1042_9(String &) = Store : &:r1042_4, r1042_8 +# 1042| r1042_10(glval) = FieldAddress[x] : r1042_2 +# 1042| r1042_11(glval) = VariableAddress[x] : +# 1042| r1042_12(int) = Load : &:r1042_11, m1031_5 +# 1042| mu1042_13(int) = Store : &:r1042_10, r1042_12 +# 1042| r1042_14(decltype([...](...){...})) = Load : &:r1042_2, ~mu1031_3 +# 1042| mu1042_15(decltype([...](...){...})) = Store : &:r1042_1, r1042_14 +# 1043| r1043_1(glval) = VariableAddress[lambda_mixed_explicit] : +# 1043| r1043_2(glval) = Convert : r1043_1 +# 1043| r1043_3(glval) = FunctionAddress[operator()] : +# 1043| r1043_4(float) = Constant[5.0] : +# 1043| r1043_5(char) = Call : func:r1043_3, this:r1043_2, 0:r1043_4 +# 1043| mu1043_6(unknown) = ^CallSideEffect : ~mu1031_3 +# 1043| v1043_7(void) = ^BufferReadSideEffect[-1] : &:r1043_2, ~mu1031_3 +# 1043| mu1043_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1043_2 +# 1044| r1044_1(glval) = VariableAddress[r] : +# 1044| r1044_2(glval) = VariableAddress[x] : +# 1044| r1044_3(int) = Load : &:r1044_2, m1031_5 +# 1044| r1044_4(int) = Constant[1] : +# 1044| r1044_5(int) = Sub : r1044_3, r1044_4 +# 1044| m1044_6(int) = Store : &:r1044_1, r1044_5 +# 1045| r1045_1(glval) = VariableAddress[lambda_inits] : +# 1045| r1045_2(glval) = VariableAddress[#temp1045:22] : +# 1045| mu1045_3(decltype([...](...){...})) = Uninitialized[#temp1045:22] : &:r1045_2 +# 1045| r1045_4(glval) = FieldAddress[s] : r1045_2 +# 1045| r1045_5(glval) = VariableAddress[s] : +# 1045| r1045_6(String &) = Load : &:r1045_5, m1031_7 +# 1045| r1045_7(glval) = CopyValue : r1045_6 +# 1045| r1045_8(String &) = CopyValue : r1045_7 +# 1045| mu1045_9(String &) = Store : &:r1045_4, r1045_8 +# 1045| r1045_10(glval) = FieldAddress[x] : r1045_2 +# 1045| r1045_11(glval) = VariableAddress[x] : +# 1045| r1045_12(int) = Load : &:r1045_11, m1031_5 +# 1045| mu1045_13(int) = Store : &:r1045_10, r1045_12 +# 1045| r1045_14(glval) = FieldAddress[i] : r1045_2 +# 1045| r1045_15(glval) = VariableAddress[x] : +# 1045| r1045_16(int) = Load : &:r1045_15, m1031_5 +# 1045| r1045_17(int) = Constant[1] : +# 1045| r1045_18(int) = Add : r1045_16, r1045_17 +# 1045| mu1045_19(int) = Store : &:r1045_14, r1045_18 +# 1045| r1045_20(glval) = FieldAddress[j] : r1045_2 +# 1045| r1045_21(glval) = VariableAddress[r] : +# 1045| r1045_22(int &) = CopyValue : r1045_21 +# 1045| mu1045_23(int &) = Store : &:r1045_20, r1045_22 +# 1045| r1045_24(decltype([...](...){...})) = Load : &:r1045_2, ~mu1031_3 +# 1045| mu1045_25(decltype([...](...){...})) = Store : &:r1045_1, r1045_24 +# 1046| r1046_1(glval) = VariableAddress[lambda_inits] : +# 1046| r1046_2(glval) = Convert : r1046_1 +# 1046| r1046_3(glval) = FunctionAddress[operator()] : +# 1046| r1046_4(float) = Constant[6.0] : +# 1046| r1046_5(char) = Call : func:r1046_3, this:r1046_2, 0:r1046_4 +# 1046| mu1046_6(unknown) = ^CallSideEffect : ~mu1031_3 +# 1046| v1046_7(void) = ^BufferReadSideEffect[-1] : &:r1046_2, ~mu1031_3 +# 1046| mu1046_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1046_2 +# 1047| v1047_1(void) = NoOp : +# 1031| v1031_10(void) = ReturnIndirection : &:r1031_8, ~mu1031_3 +# 1031| v1031_11(void) = ReturnVoid : +# 1031| v1031_12(void) = UnmodeledUse : mu* +# 1031| v1031_13(void) = AliasedUse : ~mu1031_3 +# 1031| v1031_14(void) = ExitFunction : + +# 1032| char (void Lambda(int, String const&))::(lambda [] type at line 1032, col. 23)::operator()(float) const +# 1032| Block 0 +# 1032| v1032_1(void) = EnterFunction : +# 1032| mu1032_2(unknown) = AliasedDefinition : +# 1032| mu1032_3(unknown) = UnmodeledDefinition : +# 1032| r1032_4(glval) = InitializeThis : +# 1032| r1032_5(glval) = VariableAddress[f] : +# 1032| m1032_6(float) = InitializeParameter[f] : &:r1032_5 +# 1032| r1032_7(glval) = VariableAddress[#return] : +# 1032| r1032_8(char) = Constant[65] : +# 1032| m1032_9(char) = Store : &:r1032_7, r1032_8 +# 1032| r1032_10(glval) = VariableAddress[#return] : +# 1032| v1032_11(void) = ReturnValue : &:r1032_10, m1032_9 +# 1032| v1032_12(void) = UnmodeledUse : mu* +# 1032| v1032_13(void) = AliasedUse : ~mu1032_3 +# 1032| v1032_14(void) = ExitFunction : + +# 1032| char(* (void Lambda(int, String const&))::(lambda [] type at line 1032, col. 23)::operator char (*)(float)() const)(float) +# 1032| Block 0 +# 1032| v1032_1(void) = EnterFunction : +# 1032| mu1032_2(unknown) = AliasedDefinition : +# 1032| mu1032_3(unknown) = UnmodeledDefinition : +# 1032| r1032_4(glval) = InitializeThis : +# 1032| r1032_5(glval<..(*)(..)>) = VariableAddress[#return] : +# 1032| r1032_6(..(*)(..)) = FunctionAddress[_FUN] : +# 1032| m1032_7(..(*)(..)) = Store : &:r1032_5, r1032_6 +# 1032| r1032_8(glval<..(*)(..)>) = VariableAddress[#return] : +# 1032| v1032_9(void) = ReturnValue : &:r1032_8, m1032_7 +# 1032| v1032_10(void) = UnmodeledUse : mu* +# 1032| v1032_11(void) = AliasedUse : ~mu1032_3 +# 1032| v1032_12(void) = ExitFunction : + +# 1034| char (void Lambda(int, String const&))::(lambda [] type at line 1034, col. 21)::operator()(float) const +# 1034| Block 0 +# 1034| v1034_1(void) = EnterFunction : +# 1034| mu1034_2(unknown) = AliasedDefinition : +# 1034| mu1034_3(unknown) = UnmodeledDefinition : +# 1034| r1034_4(glval) = InitializeThis : +# 1034| r1034_5(glval) = VariableAddress[f] : +# 1034| m1034_6(float) = InitializeParameter[f] : &:r1034_5 +# 1034| r1034_7(glval) = VariableAddress[#return] : +#-----| r0_1(lambda [] type at line 1034, col. 21 *) = CopyValue : r1034_4 +#-----| r0_2(glval) = FieldAddress[s] : r0_1 +#-----| r0_3(String &) = Load : &:r0_2, ~mu1034_3 +# 1034| r1034_8(glval) = CopyValue : r0_3 +# 1034| r1034_9(glval) = FunctionAddress[c_str] : +# 1034| r1034_10(char *) = Call : func:r1034_9, this:r1034_8 +# 1034| mu1034_11(unknown) = ^CallSideEffect : ~mu1034_3 +# 1034| v1034_12(void) = ^BufferReadSideEffect[-1] : &:r1034_8, ~mu1034_3 +# 1034| mu1034_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r1034_8 +#-----| r0_4(lambda [] type at line 1034, col. 21 *) = CopyValue : r1034_4 +#-----| r0_5(glval) = FieldAddress[x] : r0_4 +#-----| r0_6(int &) = Load : &:r0_5, ~mu1034_3 +# 1034| r1034_14(int) = Load : &:r0_6, ~mu1034_3 +# 1034| r1034_15(glval) = PointerAdd[1] : r1034_10, r1034_14 +# 1034| r1034_16(char) = Load : &:r1034_15, ~mu1034_3 +# 1034| m1034_17(char) = Store : &:r1034_7, r1034_16 +# 1034| r1034_18(glval) = VariableAddress[#return] : +# 1034| v1034_19(void) = ReturnValue : &:r1034_18, m1034_17 +# 1034| v1034_20(void) = UnmodeledUse : mu* +# 1034| v1034_21(void) = AliasedUse : ~mu1034_3 +# 1034| v1034_22(void) = ExitFunction : + +# 1036| void (void Lambda(int, String const&))::(lambda [] type at line 1036, col. 21)::~() +# 1036| Block 0 +# 1036| v1036_1(void) = EnterFunction : +# 1036| mu1036_2(unknown) = AliasedDefinition : +# 1036| mu1036_3(unknown) = UnmodeledDefinition : +# 1036| r1036_4(glval) = InitializeThis : +#-----| v0_1(void) = NoOp : +# 1036| r1036_5(glval) = FieldAddress[s] : r1036_4 +# 1036| r1036_6(glval) = FunctionAddress[~String] : +# 1036| v1036_7(void) = Call : func:r1036_6, this:r1036_5 +# 1036| mu1036_8(unknown) = ^CallSideEffect : ~mu1036_3 +# 1036| v1036_9(void) = ReturnVoid : +# 1036| v1036_10(void) = UnmodeledUse : mu* +# 1036| v1036_11(void) = AliasedUse : ~mu1036_3 +# 1036| v1036_12(void) = ExitFunction : + +# 1036| char (void Lambda(int, String const&))::(lambda [] type at line 1036, col. 21)::operator()(float) const +# 1036| Block 0 +# 1036| v1036_1(void) = EnterFunction : +# 1036| mu1036_2(unknown) = AliasedDefinition : +# 1036| mu1036_3(unknown) = UnmodeledDefinition : +# 1036| r1036_4(glval) = InitializeThis : +# 1036| r1036_5(glval) = VariableAddress[f] : +# 1036| m1036_6(float) = InitializeParameter[f] : &:r1036_5 +# 1036| r1036_7(glval) = VariableAddress[#return] : +#-----| r0_1(lambda [] type at line 1036, col. 21 *) = CopyValue : r1036_4 +#-----| r0_2(glval) = FieldAddress[s] : r0_1 +# 1036| r1036_8(glval) = FunctionAddress[c_str] : +# 1036| r1036_9(char *) = Call : func:r1036_8, this:r0_2 +# 1036| mu1036_10(unknown) = ^CallSideEffect : ~mu1036_3 +#-----| v0_3(void) = ^BufferReadSideEffect[-1] : &:r0_2, ~mu1036_3 +#-----| mu0_4(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_2 +#-----| r0_5(lambda [] type at line 1036, col. 21 *) = CopyValue : r1036_4 +#-----| r0_6(glval) = FieldAddress[x] : r0_5 +#-----| r0_7(int) = Load : &:r0_6, ~mu1036_3 +# 1036| r1036_11(glval) = PointerAdd[1] : r1036_9, r0_7 +# 1036| r1036_12(char) = Load : &:r1036_11, ~mu1036_3 +# 1036| m1036_13(char) = Store : &:r1036_7, r1036_12 +# 1036| r1036_14(glval) = VariableAddress[#return] : +# 1036| v1036_15(void) = ReturnValue : &:r1036_14, m1036_13 +# 1036| v1036_16(void) = UnmodeledUse : mu* +# 1036| v1036_17(void) = AliasedUse : ~mu1036_3 +# 1036| v1036_18(void) = ExitFunction : + +# 1038| char (void Lambda(int, String const&))::(lambda [] type at line 1038, col. 30)::operator()(float) const +# 1038| Block 0 +# 1038| v1038_1(void) = EnterFunction : +# 1038| mu1038_2(unknown) = AliasedDefinition : +# 1038| mu1038_3(unknown) = UnmodeledDefinition : +# 1038| r1038_4(glval) = InitializeThis : +# 1038| r1038_5(glval) = VariableAddress[f] : +# 1038| m1038_6(float) = InitializeParameter[f] : &:r1038_5 +# 1038| r1038_7(glval) = VariableAddress[#return] : +#-----| r0_1(lambda [] type at line 1038, col. 30 *) = CopyValue : r1038_4 +#-----| r0_2(glval) = FieldAddress[s] : r0_1 +#-----| r0_3(String &) = Load : &:r0_2, ~mu1038_3 +# 1038| r1038_8(glval) = CopyValue : r0_3 +# 1038| r1038_9(glval) = FunctionAddress[c_str] : +# 1038| r1038_10(char *) = Call : func:r1038_9, this:r1038_8 +# 1038| mu1038_11(unknown) = ^CallSideEffect : ~mu1038_3 +# 1038| v1038_12(void) = ^BufferReadSideEffect[-1] : &:r1038_8, ~mu1038_3 +# 1038| mu1038_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r1038_8 +# 1038| r1038_14(int) = Constant[0] : +# 1038| r1038_15(glval) = PointerAdd[1] : r1038_10, r1038_14 +# 1038| r1038_16(char) = Load : &:r1038_15, ~mu1038_3 +# 1038| m1038_17(char) = Store : &:r1038_7, r1038_16 +# 1038| r1038_18(glval) = VariableAddress[#return] : +# 1038| v1038_19(void) = ReturnValue : &:r1038_18, m1038_17 +# 1038| v1038_20(void) = UnmodeledUse : mu* +# 1038| v1038_21(void) = AliasedUse : ~mu1038_3 +# 1038| v1038_22(void) = ExitFunction : + +# 1040| void (void Lambda(int, String const&))::(lambda [] type at line 1040, col. 30)::~() +# 1040| Block 0 +# 1040| v1040_1(void) = EnterFunction : +# 1040| mu1040_2(unknown) = AliasedDefinition : +# 1040| mu1040_3(unknown) = UnmodeledDefinition : +# 1040| r1040_4(glval) = InitializeThis : +#-----| v0_1(void) = NoOp : +# 1040| r1040_5(glval) = FieldAddress[s] : r1040_4 +# 1040| r1040_6(glval) = FunctionAddress[~String] : +# 1040| v1040_7(void) = Call : func:r1040_6, this:r1040_5 +# 1040| mu1040_8(unknown) = ^CallSideEffect : ~mu1040_3 +# 1040| v1040_9(void) = ReturnVoid : +# 1040| v1040_10(void) = UnmodeledUse : mu* +# 1040| v1040_11(void) = AliasedUse : ~mu1040_3 +# 1040| v1040_12(void) = ExitFunction : + +# 1040| char (void Lambda(int, String const&))::(lambda [] type at line 1040, col. 30)::operator()(float) const +# 1040| Block 0 +# 1040| v1040_1(void) = EnterFunction : +# 1040| mu1040_2(unknown) = AliasedDefinition : +# 1040| mu1040_3(unknown) = UnmodeledDefinition : +# 1040| r1040_4(glval) = InitializeThis : +# 1040| r1040_5(glval) = VariableAddress[f] : +# 1040| m1040_6(float) = InitializeParameter[f] : &:r1040_5 +# 1040| r1040_7(glval) = VariableAddress[#return] : +#-----| r0_1(lambda [] type at line 1040, col. 30 *) = CopyValue : r1040_4 +#-----| r0_2(glval) = FieldAddress[s] : r0_1 +# 1040| r1040_8(glval) = FunctionAddress[c_str] : +# 1040| r1040_9(char *) = Call : func:r1040_8, this:r0_2 +# 1040| mu1040_10(unknown) = ^CallSideEffect : ~mu1040_3 +#-----| v0_3(void) = ^BufferReadSideEffect[-1] : &:r0_2, ~mu1040_3 +#-----| mu0_4(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_2 +# 1040| r1040_11(int) = Constant[0] : +# 1040| r1040_12(glval) = PointerAdd[1] : r1040_9, r1040_11 +# 1040| r1040_13(char) = Load : &:r1040_12, ~mu1040_3 +# 1040| m1040_14(char) = Store : &:r1040_7, r1040_13 +# 1040| r1040_15(glval) = VariableAddress[#return] : +# 1040| v1040_16(void) = ReturnValue : &:r1040_15, m1040_14 +# 1040| v1040_17(void) = UnmodeledUse : mu* +# 1040| v1040_18(void) = AliasedUse : ~mu1040_3 +# 1040| v1040_19(void) = ExitFunction : + +# 1042| char (void Lambda(int, String const&))::(lambda [] type at line 1042, col. 32)::operator()(float) const +# 1042| Block 0 +# 1042| v1042_1(void) = EnterFunction : +# 1042| mu1042_2(unknown) = AliasedDefinition : +# 1042| mu1042_3(unknown) = UnmodeledDefinition : +# 1042| r1042_4(glval) = InitializeThis : +# 1042| r1042_5(glval) = VariableAddress[f] : +# 1042| m1042_6(float) = InitializeParameter[f] : &:r1042_5 +# 1042| r1042_7(glval) = VariableAddress[#return] : +#-----| r0_1(lambda [] type at line 1042, col. 32 *) = CopyValue : r1042_4 +#-----| r0_2(glval) = FieldAddress[s] : r0_1 +#-----| r0_3(String &) = Load : &:r0_2, ~mu1042_3 +# 1042| r1042_8(glval) = CopyValue : r0_3 +# 1042| r1042_9(glval) = FunctionAddress[c_str] : +# 1042| r1042_10(char *) = Call : func:r1042_9, this:r1042_8 +# 1042| mu1042_11(unknown) = ^CallSideEffect : ~mu1042_3 +# 1042| v1042_12(void) = ^BufferReadSideEffect[-1] : &:r1042_8, ~mu1042_3 +# 1042| mu1042_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r1042_8 +#-----| r0_4(lambda [] type at line 1042, col. 32 *) = CopyValue : r1042_4 +#-----| r0_5(glval) = FieldAddress[x] : r0_4 +#-----| r0_6(int) = Load : &:r0_5, ~mu1042_3 +# 1042| r1042_14(glval) = PointerAdd[1] : r1042_10, r0_6 +# 1042| r1042_15(char) = Load : &:r1042_14, ~mu1042_3 +# 1042| m1042_16(char) = Store : &:r1042_7, r1042_15 +# 1042| r1042_17(glval) = VariableAddress[#return] : +# 1042| v1042_18(void) = ReturnValue : &:r1042_17, m1042_16 +# 1042| v1042_19(void) = UnmodeledUse : mu* +# 1042| v1042_20(void) = AliasedUse : ~mu1042_3 +# 1042| v1042_21(void) = ExitFunction : + +# 1045| char (void Lambda(int, String const&))::(lambda [] type at line 1045, col. 23)::operator()(float) const +# 1045| Block 0 +# 1045| v1045_1(void) = EnterFunction : +# 1045| mu1045_2(unknown) = AliasedDefinition : +# 1045| mu1045_3(unknown) = UnmodeledDefinition : +# 1045| r1045_4(glval) = InitializeThis : +# 1045| r1045_5(glval) = VariableAddress[f] : +# 1045| m1045_6(float) = InitializeParameter[f] : &:r1045_5 +# 1045| r1045_7(glval) = VariableAddress[#return] : +#-----| r0_1(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 +#-----| r0_2(glval) = FieldAddress[s] : r0_1 +#-----| r0_3(String &) = Load : &:r0_2, ~mu1045_3 +# 1045| r1045_8(glval) = CopyValue : r0_3 +# 1045| r1045_9(glval) = FunctionAddress[c_str] : +# 1045| r1045_10(char *) = Call : func:r1045_9, this:r1045_8 +# 1045| mu1045_11(unknown) = ^CallSideEffect : ~mu1045_3 +# 1045| v1045_12(void) = ^BufferReadSideEffect[-1] : &:r1045_8, ~mu1045_3 +# 1045| mu1045_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r1045_8 +#-----| r0_4(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 +#-----| r0_5(glval) = FieldAddress[x] : r0_4 +#-----| r0_6(int) = Load : &:r0_5, ~mu1045_3 +#-----| r0_7(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 +# 1045| r1045_14(glval) = FieldAddress[i] : r0_7 +# 1045| r1045_15(int) = Load : &:r1045_14, ~mu1045_3 +# 1045| r1045_16(int) = Add : r0_6, r1045_15 +#-----| r0_8(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 +# 1045| r1045_17(glval) = FieldAddress[j] : r0_8 +# 1045| r1045_18(int &) = Load : &:r1045_17, ~mu1045_3 +# 1045| r1045_19(int) = Load : &:r1045_18, ~mu1045_3 +# 1045| r1045_20(int) = Sub : r1045_16, r1045_19 +# 1045| r1045_21(glval) = PointerAdd[1] : r1045_10, r1045_20 +# 1045| r1045_22(char) = Load : &:r1045_21, ~mu1045_3 +# 1045| m1045_23(char) = Store : &:r1045_7, r1045_22 +# 1045| r1045_24(glval) = VariableAddress[#return] : +# 1045| v1045_25(void) = ReturnValue : &:r1045_24, m1045_23 +# 1045| v1045_26(void) = UnmodeledUse : mu* +# 1045| v1045_27(void) = AliasedUse : ~mu1045_3 +# 1045| v1045_28(void) = ExitFunction : + +# 1068| void RangeBasedFor(vector const&) +# 1068| Block 0 +# 1068| v1068_1(void) = EnterFunction : +# 1068| mu1068_2(unknown) = AliasedDefinition : +# 1068| mu1068_3(unknown) = UnmodeledDefinition : +# 1068| r1068_4(glval &>) = VariableAddress[v] : +# 1068| m1068_5(vector &) = InitializeParameter[v] : &:r1068_4 +# 1068| r1068_6(vector &) = Load : &:r1068_4, m1068_5 +# 1068| mu1068_7(unknown) = InitializeIndirection[v] : &:r1068_6 +# 1069| r1069_1(glval &>) = VariableAddress[(__range)] : +# 1069| r1069_2(glval &>) = VariableAddress[v] : +# 1069| r1069_3(vector &) = Load : &:r1069_2, m1068_5 +# 1069| r1069_4(glval>) = CopyValue : r1069_3 +# 1069| r1069_5(vector &) = CopyValue : r1069_4 +# 1069| m1069_6(vector &) = Store : &:r1069_1, r1069_5 +# 1069| r1069_7(glval) = VariableAddress[(__begin)] : +#-----| r0_1(glval &>) = VariableAddress[(__range)] : +#-----| r0_2(vector &) = Load : &:r0_1, m1069_6 +#-----| r0_3(glval>) = CopyValue : r0_2 +# 1069| r1069_8(glval) = FunctionAddress[begin] : +# 1069| r1069_9(iterator) = Call : func:r1069_8, this:r0_3 +# 1069| mu1069_10(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_4(void) = ^BufferReadSideEffect[-1] : &:r0_3, ~mu1068_3 +#-----| mu0_5(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_3 +# 1069| mu1069_11(iterator) = Store : &:r1069_7, r1069_9 +# 1069| r1069_12(glval) = VariableAddress[(__end)] : +#-----| r0_6(glval &>) = VariableAddress[(__range)] : +#-----| r0_7(vector &) = Load : &:r0_6, m1069_6 +#-----| r0_8(glval>) = CopyValue : r0_7 +# 1069| r1069_13(glval) = FunctionAddress[end] : +# 1069| r1069_14(iterator) = Call : func:r1069_13, this:r0_8 +# 1069| mu1069_15(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_9(void) = ^BufferReadSideEffect[-1] : &:r0_8, ~mu1068_3 +#-----| mu0_10(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 +# 1069| m1069_16(iterator) = Store : &:r1069_12, r1069_14 +#-----| Goto -> Block 6 + +#-----| Block 1 +#-----| r0_11(glval) = VariableAddress[(__begin)] : +#-----| r0_12(glval) = Convert : r0_11 +# 1075| r1075_1(glval) = FunctionAddress[operator!=] : +#-----| r0_13(glval) = VariableAddress[(__end)] : +#-----| r0_14(iterator) = Load : &:r0_13, m1075_32 +# 1075| r1075_2(bool) = Call : func:r1075_1, this:r0_12, 0:r0_14 +# 1075| mu1075_3(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_15(void) = ^BufferReadSideEffect[-1] : &:r0_12, ~mu1068_3 +#-----| mu0_16(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_12 +# 1075| v1075_4(void) = ConditionalBranch : r1075_2 +#-----| False -> Block 5 +#-----| True -> Block 3 + +#-----| Block 2 +#-----| r0_17(glval) = VariableAddress[(__begin)] : +# 1075| r1075_5(glval) = FunctionAddress[operator++] : +# 1075| r1075_6(iterator &) = Call : func:r1075_5, this:r0_17 +# 1075| mu1075_7(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_18(void) = ^BufferReadSideEffect[-1] : &:r0_17, ~mu1068_3 +#-----| mu0_19(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_17 +# 1075| r1075_8(glval) = CopyValue : r1075_6 +#-----| Goto (back edge) -> Block 1 + +# 1075| Block 3 +# 1075| r1075_9(glval) = VariableAddress[e] : +#-----| r0_20(glval) = VariableAddress[(__begin)] : +#-----| r0_21(glval) = Convert : r0_20 +# 1075| r1075_10(glval) = FunctionAddress[operator*] : +# 1075| r1075_11(int &) = Call : func:r1075_10, this:r0_21 +# 1075| mu1075_12(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_22(void) = ^BufferReadSideEffect[-1] : &:r0_21, ~mu1068_3 +#-----| mu0_23(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_21 +# 1075| r1075_13(glval) = CopyValue : r1075_11 +# 1075| r1075_14(glval) = Convert : r1075_13 +# 1075| r1075_15(int &) = CopyValue : r1075_14 +# 1075| m1075_16(int &) = Store : &:r1075_9, r1075_15 +# 1076| r1076_1(glval) = VariableAddress[e] : +# 1076| r1076_2(int &) = Load : &:r1076_1, m1075_16 +# 1076| r1076_3(int) = Load : &:r1076_2, ~mu1068_3 +# 1076| r1076_4(int) = Constant[5] : +# 1076| r1076_5(bool) = CompareLT : r1076_3, r1076_4 +# 1076| v1076_6(void) = ConditionalBranch : r1076_5 +#-----| False -> Block 2 +#-----| True -> Block 4 + +# 1077| Block 4 +# 1077| v1077_1(void) = NoOp : +#-----| Goto -> Block 5 + +# 1079| Block 5 +# 1079| v1079_1(void) = NoOp : +# 1080| v1080_1(void) = NoOp : +# 1068| v1068_8(void) = ReturnIndirection : &:r1068_6, ~mu1068_3 +# 1068| v1068_9(void) = ReturnVoid : +# 1068| v1068_10(void) = UnmodeledUse : mu* +# 1068| v1068_11(void) = AliasedUse : ~mu1068_3 +# 1068| v1068_12(void) = ExitFunction : + +#-----| Block 6 +#-----| r0_24(glval) = VariableAddress[(__begin)] : +#-----| r0_25(glval) = Convert : r0_24 +# 1069| r1069_17(glval) = FunctionAddress[operator!=] : +#-----| r0_26(glval) = VariableAddress[(__end)] : +#-----| r0_27(iterator) = Load : &:r0_26, m1069_16 +# 1069| r1069_18(bool) = Call : func:r1069_17, this:r0_25, 0:r0_27 +# 1069| mu1069_19(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_28(void) = ^BufferReadSideEffect[-1] : &:r0_25, ~mu1068_3 +#-----| mu0_29(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_25 +# 1069| v1069_20(void) = ConditionalBranch : r1069_18 +#-----| False -> Block 10 +#-----| True -> Block 7 + +# 1069| Block 7 +# 1069| r1069_21(glval) = VariableAddress[e] : +#-----| r0_30(glval) = VariableAddress[(__begin)] : +#-----| r0_31(glval) = Convert : r0_30 +# 1069| r1069_22(glval) = FunctionAddress[operator*] : +# 1069| r1069_23(int &) = Call : func:r1069_22, this:r0_31 +# 1069| mu1069_24(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_32(void) = ^BufferReadSideEffect[-1] : &:r0_31, ~mu1068_3 +#-----| mu0_33(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_31 +# 1069| r1069_25(int) = Load : &:r1069_23, ~mu1068_3 +# 1069| m1069_26(int) = Store : &:r1069_21, r1069_25 +# 1070| r1070_1(glval) = VariableAddress[e] : +# 1070| r1070_2(int) = Load : &:r1070_1, m1069_26 +# 1070| r1070_3(int) = Constant[0] : +# 1070| r1070_4(bool) = CompareGT : r1070_2, r1070_3 +# 1070| v1070_5(void) = ConditionalBranch : r1070_4 +#-----| False -> Block 9 +#-----| True -> Block 8 + +# 1071| Block 8 +# 1071| v1071_1(void) = NoOp : +#-----| Goto -> Block 9 + +# 1069| Block 9 +# 1069| v1069_27(void) = NoOp : +#-----| r0_34(glval) = VariableAddress[(__begin)] : +# 1069| r1069_28(glval) = FunctionAddress[operator++] : +# 1069| r1069_29(iterator &) = Call : func:r1069_28, this:r0_34 +# 1069| mu1069_30(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_35(void) = ^BufferReadSideEffect[-1] : &:r0_34, ~mu1068_3 +#-----| mu0_36(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_34 +# 1069| r1069_31(glval) = CopyValue : r1069_29 +#-----| Goto (back edge) -> Block 6 + +# 1075| Block 10 +# 1075| r1075_17(glval &>) = VariableAddress[(__range)] : +# 1075| r1075_18(glval &>) = VariableAddress[v] : +# 1075| r1075_19(vector &) = Load : &:r1075_18, m1068_5 +# 1075| r1075_20(glval>) = CopyValue : r1075_19 +# 1075| r1075_21(vector &) = CopyValue : r1075_20 +# 1075| m1075_22(vector &) = Store : &:r1075_17, r1075_21 +# 1075| r1075_23(glval) = VariableAddress[(__begin)] : +#-----| r0_37(glval &>) = VariableAddress[(__range)] : +#-----| r0_38(vector &) = Load : &:r0_37, m1075_22 +#-----| r0_39(glval>) = CopyValue : r0_38 +# 1075| r1075_24(glval) = FunctionAddress[begin] : +# 1075| r1075_25(iterator) = Call : func:r1075_24, this:r0_39 +# 1075| mu1075_26(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_40(void) = ^BufferReadSideEffect[-1] : &:r0_39, ~mu1068_3 +#-----| mu0_41(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_39 +# 1075| mu1075_27(iterator) = Store : &:r1075_23, r1075_25 +# 1075| r1075_28(glval) = VariableAddress[(__end)] : +#-----| r0_42(glval &>) = VariableAddress[(__range)] : +#-----| r0_43(vector &) = Load : &:r0_42, m1075_22 +#-----| r0_44(glval>) = CopyValue : r0_43 +# 1075| r1075_29(glval) = FunctionAddress[end] : +# 1075| r1075_30(iterator) = Call : func:r1075_29, this:r0_44 +# 1075| mu1075_31(unknown) = ^CallSideEffect : ~mu1068_3 +#-----| v0_45(void) = ^BufferReadSideEffect[-1] : &:r0_44, ~mu1068_3 +#-----| mu0_46(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_44 +# 1075| m1075_32(iterator) = Store : &:r1075_28, r1075_30 +#-----| Goto -> Block 1 + +# 1099| int AsmStmt(int) +# 1099| Block 0 +# 1099| v1099_1(void) = EnterFunction : +# 1099| mu1099_2(unknown) = AliasedDefinition : +# 1099| mu1099_3(unknown) = UnmodeledDefinition : +# 1099| r1099_4(glval) = VariableAddress[x] : +# 1099| m1099_5(int) = InitializeParameter[x] : &:r1099_4 +# 1100| mu1100_1(unknown) = InlineAsm : ~mu1099_3 +# 1101| r1101_1(glval) = VariableAddress[#return] : +# 1101| r1101_2(glval) = VariableAddress[x] : +# 1101| r1101_3(int) = Load : &:r1101_2, m1099_5 +# 1101| m1101_4(int) = Store : &:r1101_1, r1101_3 +# 1099| r1099_6(glval) = VariableAddress[#return] : +# 1099| v1099_7(void) = ReturnValue : &:r1099_6, m1101_4 +# 1099| v1099_8(void) = UnmodeledUse : mu* +# 1099| v1099_9(void) = AliasedUse : ~mu1099_3 +# 1099| v1099_10(void) = ExitFunction : + +# 1104| void AsmStmtWithOutputs(unsigned int&, unsigned int, unsigned int&, unsigned int) +# 1104| Block 0 +# 1104| v1104_1(void) = EnterFunction : +# 1104| mu1104_2(unknown) = AliasedDefinition : +# 1104| mu1104_3(unknown) = UnmodeledDefinition : +# 1104| r1104_4(glval) = VariableAddress[a] : +# 1104| m1104_5(unsigned int &) = InitializeParameter[a] : &:r1104_4 +# 1104| r1104_6(unsigned int &) = Load : &:r1104_4, m1104_5 +# 1104| mu1104_7(unknown) = InitializeIndirection[a] : &:r1104_6 +# 1104| r1104_8(glval) = VariableAddress[b] : +# 1104| m1104_9(unsigned int) = InitializeParameter[b] : &:r1104_8 +# 1104| r1104_10(glval) = VariableAddress[c] : +# 1104| m1104_11(unsigned int &) = InitializeParameter[c] : &:r1104_10 +# 1104| r1104_12(unsigned int &) = Load : &:r1104_10, m1104_11 +# 1104| mu1104_13(unknown) = InitializeIndirection[c] : &:r1104_12 +# 1104| r1104_14(glval) = VariableAddress[d] : +# 1104| m1104_15(unsigned int) = InitializeParameter[d] : &:r1104_14 +# 1109| r1109_1(glval) = VariableAddress[a] : +# 1109| r1109_2(unsigned int &) = Load : &:r1109_1, m1104_5 +# 1109| r1109_3(glval) = CopyValue : r1109_2 +# 1109| r1109_4(glval) = VariableAddress[b] : +# 1109| r1109_5(glval) = VariableAddress[c] : +# 1109| r1109_6(unsigned int &) = Load : &:r1109_5, m1104_11 +# 1109| r1109_7(unsigned int) = Load : &:r1109_6, ~mu1104_3 +# 1109| r1109_8(glval) = VariableAddress[d] : +# 1109| r1109_9(unsigned int) = Load : &:r1109_8, m1104_15 +# 1106| mu1106_1(unknown) = InlineAsm : ~mu1104_3, 0:r1109_3, 1:r1109_4, 2:r1109_7, 3:r1109_9 +# 1111| v1111_1(void) = NoOp : +# 1104| v1104_16(void) = ReturnIndirection : &:r1104_6, ~mu1104_3 +# 1104| v1104_17(void) = ReturnIndirection : &:r1104_12, ~mu1104_3 +# 1104| v1104_18(void) = ReturnVoid : +# 1104| v1104_19(void) = UnmodeledUse : mu* +# 1104| v1104_20(void) = AliasedUse : ~mu1104_3 +# 1104| v1104_21(void) = ExitFunction : + +# 1113| void ExternDeclarations() +# 1113| Block 0 +# 1113| v1113_1(void) = EnterFunction : +# 1113| mu1113_2(unknown) = AliasedDefinition : +# 1113| mu1113_3(unknown) = UnmodeledDefinition : +# 1116| r1116_1(glval) = VariableAddress[x] : +# 1116| m1116_2(int) = Uninitialized[x] : &:r1116_1 +# 1117| r1117_1(glval) = VariableAddress[y] : +# 1117| m1117_2(int) = Uninitialized[y] : &:r1117_1 +# 1118| r1118_1(glval) = VariableAddress[h] : +# 1118| m1118_2(int) = Uninitialized[h] : &:r1118_1 +# 1120| v1120_1(void) = NoOp : +# 1113| v1113_4(void) = ReturnVoid : +# 1113| v1113_5(void) = UnmodeledUse : mu* +# 1113| v1113_6(void) = AliasedUse : ~mu1113_3 +# 1113| v1113_7(void) = ExitFunction : + +# 1128| void ExternDeclarationsInMacro() +# 1128| Block 0 +# 1128| v1128_1(void) = EnterFunction : +# 1128| mu1128_2(unknown) = AliasedDefinition : +# 1128| mu1128_3(unknown) = UnmodeledDefinition : +# 1130| r1130_1(glval) = VariableAddress[i] : +# 1130| r1130_2(int) = Constant[0] : +# 1130| m1130_3(int) = Store : &:r1130_1, r1130_2 +#-----| Goto -> Block 1 + +# 1130| Block 1 +# 1130| m1130_4(int) = Phi : from 0:m1130_3, from 2:m1130_14 +# 1130| r1130_5(glval) = VariableAddress[i] : +# 1130| r1130_6(int) = Load : &:r1130_5, m1130_4 +# 1130| r1130_7(int) = Constant[10] : +# 1130| r1130_8(bool) = CompareLT : r1130_6, r1130_7 +# 1130| v1130_9(void) = ConditionalBranch : r1130_8 +#-----| False -> Block 3 +#-----| True -> Block 2 + +# 1130| Block 2 +# 1130| r1130_10(glval) = VariableAddress[i] : +# 1130| r1130_11(int) = Load : &:r1130_10, m1130_4 +# 1130| r1130_12(int) = Constant[1] : +# 1130| r1130_13(int) = Add : r1130_11, r1130_12 +# 1130| m1130_14(int) = Store : &:r1130_10, r1130_13 +#-----| Goto (back edge) -> Block 1 + +# 1130| Block 3 +# 1130| v1130_15(void) = NoOp : +# 1131| v1131_1(void) = NoOp : +# 1128| v1128_4(void) = ReturnVoid : +# 1128| v1128_5(void) = UnmodeledUse : mu* +# 1128| v1128_6(void) = AliasedUse : ~mu1128_3 +# 1128| v1128_7(void) = ExitFunction : + +# 1133| void TryCatchNoCatchAny(bool) +# 1133| Block 0 +# 1133| v1133_1(void) = EnterFunction : +# 1133| mu1133_2(unknown) = AliasedDefinition : +# 1133| mu1133_3(unknown) = UnmodeledDefinition : +# 1133| r1133_4(glval) = VariableAddress[b] : +# 1133| m1133_5(bool) = InitializeParameter[b] : &:r1133_4 +# 1135| r1135_1(glval) = VariableAddress[x] : +# 1135| r1135_2(int) = Constant[5] : +# 1135| m1135_3(int) = Store : &:r1135_1, r1135_2 +# 1136| r1136_1(glval) = VariableAddress[b] : +# 1136| r1136_2(bool) = Load : &:r1136_1, m1133_5 +# 1136| v1136_3(void) = ConditionalBranch : r1136_2 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 1133| Block 1 +# 1133| v1133_6(void) = UnmodeledUse : mu* +# 1133| v1133_7(void) = AliasedUse : ~mu1133_3 +# 1133| v1133_8(void) = ExitFunction : + +# 1133| Block 2 +# 1133| v1133_9(void) = Unwind : +#-----| Goto -> Block 1 + +# 1137| Block 3 +# 1137| r1137_1(glval) = VariableAddress[#throw1137:7] : +# 1137| r1137_2(glval) = StringConstant["string literal"] : +# 1137| r1137_3(char *) = Convert : r1137_2 +# 1137| m1137_4(char *) = Store : &:r1137_1, r1137_3 +# 1137| v1137_5(void) = ThrowValue : &:r1137_1, m1137_4 +#-----| Exception -> Block 9 + +# 1139| Block 4 +# 1139| r1139_1(glval) = VariableAddress[x] : +# 1139| r1139_2(int) = Load : &:r1139_1, m1135_3 +# 1139| r1139_3(int) = Constant[2] : +# 1139| r1139_4(bool) = CompareLT : r1139_2, r1139_3 +# 1139| v1139_5(void) = ConditionalBranch : r1139_4 +#-----| False -> Block 8 +#-----| True -> Block 5 + +# 1140| Block 5 +# 1140| r1140_1(glval) = VariableAddress[b] : +# 1140| r1140_2(bool) = Load : &:r1140_1, m1133_5 +# 1140| v1140_3(void) = ConditionalBranch : r1140_2 +#-----| False -> Block 7 +#-----| True -> Block 6 + +# 1140| Block 6 +# 1140| r1140_4(int) = Constant[7] : +# 1140| r1140_5(glval) = VariableAddress[#temp1140:11] : +# 1140| m1140_6(int) = Store : &:r1140_5, r1140_4 +# 1140| r1140_7(glval) = VariableAddress[#temp1140:11] : +# 1140| r1140_8(int) = Load : &:r1140_7, m1140_6 +# 1140| r1140_9(glval) = VariableAddress[x] : +# 1140| m1140_10(int) = Store : &:r1140_9, r1140_8 +#-----| Goto -> Block 8 + +# 1140| Block 7 +# 1140| r1140_11(glval) = VariableAddress[#throw1140:19] : +# 1140| m1140_12(String) = Uninitialized[#throw1140:19] : &:r1140_11 +# 1140| r1140_13(glval) = FunctionAddress[String] : +# 1140| r1140_14(glval) = StringConstant["String object"] : +# 1140| r1140_15(char *) = Convert : r1140_14 +# 1140| v1140_16(void) = Call : func:r1140_13, this:r1140_11, 0:r1140_15 +# 1140| mu1140_17(unknown) = ^CallSideEffect : ~mu1133_3 +# 1140| m1140_18(String) = ^IndirectMayWriteSideEffect[-1] : &:r1140_11 +# 1140| v1140_19(void) = ^BufferReadSideEffect[0] : &:r1140_15, ~mu1133_3 +# 1140| mu1140_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r1140_15 +# 1140| v1140_21(void) = ThrowValue : &:r1140_11, m1140_18 +#-----| Exception -> Block 9 + +# 1142| Block 8 +# 1142| r1142_1(int) = Constant[7] : +# 1142| r1142_2(glval) = VariableAddress[x] : +# 1142| m1142_3(int) = Store : &:r1142_2, r1142_1 +#-----| Goto -> Block 13 + +# 1144| Block 9 +# 1144| v1144_1(void) = CatchByType[const char *] : +#-----| Exception -> Block 11 +#-----| Goto -> Block 10 + +# 1144| Block 10 +# 1144| r1144_2(glval) = VariableAddress[s] : +# 1144| m1144_3(char *) = InitializeParameter[s] : &:r1144_2 +# 1144| r1144_4(char *) = Load : &:r1144_2, m1144_3 +# 1144| mu1144_5(unknown) = InitializeIndirection[s] : &:r1144_4 +# 1145| r1145_1(glval) = VariableAddress[#throw1145:5] : +# 1145| m1145_2(String) = Uninitialized[#throw1145:5] : &:r1145_1 +# 1145| r1145_3(glval) = FunctionAddress[String] : +# 1145| r1145_4(glval) = VariableAddress[s] : +# 1145| r1145_5(char *) = Load : &:r1145_4, m1144_3 +# 1145| v1145_6(void) = Call : func:r1145_3, this:r1145_1, 0:r1145_5 +# 1145| mu1145_7(unknown) = ^CallSideEffect : ~mu1133_3 +# 1145| m1145_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r1145_1 +# 1145| v1145_9(void) = ^BufferReadSideEffect[0] : &:r1145_5, ~mu1133_3 +# 1145| mu1145_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r1145_5 +# 1145| v1145_11(void) = ThrowValue : &:r1145_1, m1145_8 +#-----| Exception -> Block 2 + +# 1147| Block 11 +# 1147| v1147_1(void) = CatchByType[const String &] : +#-----| Exception -> Block 2 +#-----| Goto -> Block 12 + +# 1147| Block 12 +# 1147| r1147_2(glval) = VariableAddress[e] : +# 1147| m1147_3(String &) = InitializeParameter[e] : &:r1147_2 +# 1147| r1147_4(String &) = Load : &:r1147_2, m1147_3 +# 1147| mu1147_5(unknown) = InitializeIndirection[e] : &:r1147_4 +# 1147| v1147_6(void) = NoOp : +#-----| Goto -> Block 13 + +# 1149| Block 13 +# 1149| v1149_1(void) = NoOp : +# 1133| v1133_10(void) = ReturnVoid : +#-----| Goto -> Block 1 + +# 1153| void VectorTypes(int) +# 1153| Block 0 +# 1153| v1153_1(void) = EnterFunction : +# 1153| mu1153_2(unknown) = AliasedDefinition : +# 1153| mu1153_3(unknown) = UnmodeledDefinition : +# 1153| r1153_4(glval) = VariableAddress[i] : +# 1153| m1153_5(int) = InitializeParameter[i] : &:r1153_4 +# 1154| r1154_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1154| mu1154_2(__attribute((vector_size(16UL))) int) = Uninitialized[vi4] : &:r1154_1 +# 1154| r1154_3(int) = Constant[0] : +# 1154| r1154_4(glval) = PointerAdd[4] : r1154_1, r1154_3 +# 1154| r1154_5(int) = Constant[0] : +# 1154| mu1154_6(int) = Store : &:r1154_4, r1154_5 +# 1154| r1154_7(int) = Constant[1] : +# 1154| r1154_8(glval) = PointerAdd[4] : r1154_1, r1154_7 +# 1154| r1154_9(int) = Constant[1] : +# 1154| mu1154_10(int) = Store : &:r1154_8, r1154_9 +# 1154| r1154_11(int) = Constant[2] : +# 1154| r1154_12(glval) = PointerAdd[4] : r1154_1, r1154_11 +# 1154| r1154_13(int) = Constant[2] : +# 1154| mu1154_14(int) = Store : &:r1154_12, r1154_13 +# 1154| r1154_15(int) = Constant[3] : +# 1154| r1154_16(glval) = PointerAdd[4] : r1154_1, r1154_15 +# 1154| r1154_17(int) = Constant[3] : +# 1154| mu1154_18(int) = Store : &:r1154_16, r1154_17 +# 1155| r1155_1(glval) = VariableAddress[x] : +# 1155| r1155_2(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1155| r1155_3(glval) = VariableAddress[i] : +# 1155| r1155_4(int) = Load : &:r1155_3, m1153_5 +# 1155| r1155_5(glval) = PointerAdd[4] : r1155_2, r1155_4 +# 1155| r1155_6(int) = Load : &:r1155_5, ~mu1153_3 +# 1155| m1155_7(int) = Store : &:r1155_1, r1155_6 +# 1156| r1156_1(glval) = VariableAddress[x] : +# 1156| r1156_2(int) = Load : &:r1156_1, m1155_7 +# 1156| r1156_3(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1156| r1156_4(glval) = VariableAddress[i] : +# 1156| r1156_5(int) = Load : &:r1156_4, m1153_5 +# 1156| r1156_6(glval) = PointerAdd[4] : r1156_3, r1156_5 +# 1156| mu1156_7(int) = Store : &:r1156_6, r1156_2 +# 1157| r1157_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4_shuffle] : +# 1157| r1157_2(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1157| r1157_3(__attribute((vector_size(16UL))) int) = Load : &:r1157_2, ~mu1153_3 +# 1157| r1157_4(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1157| r1157_5(__attribute((vector_size(16UL))) int) = Load : &:r1157_4, ~mu1153_3 +#-----| r0_1(int) = Constant[3] : +# 1157| r1157_6(int) = Constant[2] : +# 1157| r1157_7(int) = Constant[1] : +# 1157| r1157_8(int) = Constant[0] : +# 1157| r1157_9(__attribute((vector_size(16))) int) = BuiltIn[__builtin_shufflevector] : 0:r1157_3, 1:r1157_5, 2:r0_1, 3:r1157_6, 4:r1157_7, 5:r1157_8 +# 1157| m1157_10(__attribute((vector_size(16UL))) int) = Store : &:r1157_1, r1157_9 +# 1158| r1158_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1158| r1158_2(__attribute((vector_size(16UL))) int) = Load : &:r1158_1, ~mu1153_3 +# 1158| r1158_3(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4_shuffle] : +# 1158| r1158_4(__attribute((vector_size(16UL))) int) = Load : &:r1158_3, m1157_10 +# 1158| r1158_5(__attribute((vector_size(16UL))) int) = Add : r1158_2, r1158_4 +# 1158| r1158_6(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : +# 1158| mu1158_7(__attribute((vector_size(16UL))) int) = Store : &:r1158_6, r1158_5 +# 1159| v1159_1(void) = NoOp : +# 1153| v1153_6(void) = ReturnVoid : +# 1153| v1153_7(void) = UnmodeledUse : mu* +# 1153| v1153_8(void) = AliasedUse : ~mu1153_3 +# 1153| v1153_9(void) = ExitFunction : + +# 1163| int ModeledCallTarget(int) +# 1163| Block 0 +# 1163| v1163_1(void) = EnterFunction : +# 1163| mu1163_2(unknown) = AliasedDefinition : +# 1163| mu1163_3(unknown) = UnmodeledDefinition : +# 1163| r1163_4(glval) = VariableAddress[x] : +# 1163| mu1163_5(int) = InitializeParameter[x] : &:r1163_4 +# 1164| r1164_1(glval) = VariableAddress[y] : +# 1164| mu1164_2(int) = Uninitialized[y] : &:r1164_1 +# 1165| r1165_1(glval) = FunctionAddress[memcpy] : +# 1165| r1165_2(glval) = VariableAddress[y] : +# 1165| r1165_3(int *) = CopyValue : r1165_2 +# 1165| r1165_4(void *) = Convert : r1165_3 +# 1165| r1165_5(glval) = VariableAddress[x] : +# 1165| r1165_6(int *) = CopyValue : r1165_5 +# 1165| r1165_7(void *) = Convert : r1165_6 +# 1165| r1165_8(int) = Constant[4] : +# 1165| r1165_9(void *) = Call : func:r1165_1, 0:r1165_4, 1:r1165_7, 2:r1165_8 +# 1165| v1165_10(void) = ^SizedBufferReadSideEffect[1] : &:r1165_7, r1165_8, ~mu1163_3 +# 1165| mu1165_11(unknown) = ^SizedBufferMustWriteSideEffect[0] : &:r1165_4, r1165_8 +# 1166| r1166_1(glval) = VariableAddress[#return] : +# 1166| r1166_2(glval) = VariableAddress[y] : +# 1166| r1166_3(int) = Load : &:r1166_2, ~mu1163_3 +# 1166| m1166_4(int) = Store : &:r1166_1, r1166_3 +# 1163| r1163_6(glval) = VariableAddress[#return] : +# 1163| v1163_7(void) = ReturnValue : &:r1163_6, m1166_4 +# 1163| v1163_8(void) = UnmodeledUse : mu* +# 1163| v1163_9(void) = AliasedUse : ~mu1163_3 +# 1163| v1163_10(void) = ExitFunction : + +# 1169| String ReturnObjectImpl() +# 1169| Block 0 +# 1169| v1169_1(void) = EnterFunction : +# 1169| mu1169_2(unknown) = AliasedDefinition : +# 1169| mu1169_3(unknown) = UnmodeledDefinition : +# 1170| r1170_1(glval) = VariableAddress[#return] : +# 1170| m1170_2(String) = Uninitialized[#return] : &:r1170_1 +# 1170| r1170_3(glval) = FunctionAddress[String] : +# 1170| r1170_4(glval) = StringConstant["foo"] : +# 1170| r1170_5(char *) = Convert : r1170_4 +# 1170| r1170_6(String) = Call : func:r1170_3, this:r1170_1, 0:r1170_5 +# 1170| mu1170_7(unknown) = ^CallSideEffect : ~mu1169_3 +# 1170| m1170_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r1170_1 +# 1170| v1170_9(void) = ^BufferReadSideEffect[0] : &:r1170_5, ~mu1169_3 +# 1170| mu1170_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r1170_5 +# 1169| r1169_4(glval) = VariableAddress[#return] : +# 1169| v1169_5(void) = ReturnValue : &:r1169_4, m1170_8 +# 1169| v1169_6(void) = UnmodeledUse : mu* +# 1169| v1169_7(void) = AliasedUse : ~mu1169_3 +# 1169| v1169_8(void) = ExitFunction : + +perf-regression.cpp: +# 6| void Big::Big() +# 6| Block 0 +# 6| v6_1(void) = EnterFunction : +# 6| mu6_2(unknown) = AliasedDefinition : +# 6| mu6_3(unknown) = UnmodeledDefinition : +# 6| r6_4(glval) = InitializeThis : +# 6| r6_5(glval) = FieldAddress[buffer] : r6_4 +# 6| r6_6(int) = Constant[0] : +# 6| r6_7(glval) = PointerAdd[1] : r6_5, r6_6 +# 6| r6_8(unknown[1073741824]) = Constant[0] : +# 6| mu6_9(unknown[1073741824]) = Store : &:r6_7, r6_8 +# 6| v6_10(void) = NoOp : +# 6| v6_11(void) = ReturnVoid : +# 6| v6_12(void) = UnmodeledUse : mu* +# 6| v6_13(void) = AliasedUse : ~mu6_3 +# 6| v6_14(void) = ExitFunction : + +# 9| int main() +# 9| Block 0 +# 9| v9_1(void) = EnterFunction : +# 9| mu9_2(unknown) = AliasedDefinition : +# 9| mu9_3(unknown) = UnmodeledDefinition : +# 10| r10_1(glval) = VariableAddress[big] : +# 10| r10_2(glval) = FunctionAddress[operator new] : +# 10| r10_3(unsigned long) = Constant[1073741824] : +# 10| r10_4(void *) = Call : func:r10_2, 0:r10_3 +# 10| mu10_5(unknown) = ^CallSideEffect : ~mu9_3 +# 10| r10_6(Big *) = Convert : r10_4 +# 10| r10_7(glval) = FunctionAddress[Big] : +# 10| v10_8(void) = Call : func:r10_7, this:r10_6 +# 10| mu10_9(unknown) = ^CallSideEffect : ~mu9_3 +# 10| mu10_10(Big) = ^IndirectMayWriteSideEffect[-1] : &:r10_6 +# 10| m10_11(Big *) = Store : &:r10_1, r10_6 +# 12| r12_1(glval) = VariableAddress[#return] : +# 12| r12_2(int) = Constant[0] : +# 12| m12_3(int) = Store : &:r12_1, r12_2 +# 9| r9_4(glval) = VariableAddress[#return] : +# 9| v9_5(void) = ReturnValue : &:r9_4, m12_3 +# 9| v9_6(void) = UnmodeledUse : mu* +# 9| v9_7(void) = AliasedUse : ~mu9_3 +# 9| v9_8(void) = ExitFunction : diff --git a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir.qlref b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.qlref similarity index 100% rename from cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir.qlref rename to cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.qlref diff --git a/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_sanity.ql b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_sanity.ql new file mode 100644 index 00000000000..c7d0ba957af --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_sanity.ql @@ -0,0 +1,2 @@ +import semmle.code.cpp.ir.implementation.unaliased_ssa.IRSanity +import semmle.code.cpp.ir.implementation.UseSoundEscapeAnalysis diff --git a/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_sanity_unsound.expected b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_sanity_unsound.expected new file mode 100644 index 00000000000..e5e666c020b --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_sanity_unsound.expected @@ -0,0 +1,26 @@ +missingOperand +| ir.cpp:809:7:809:13 | IndirectMayWriteSideEffect: call to Base | Instruction 'IndirectMayWriteSideEffect' is missing an expected operand with tag 'Address' in function '$@'. | ir.cpp:799:6:799:25 | IR: HierarchyConversions | void HierarchyConversions() | +| ir.cpp:810:7:810:26 | IndirectMayWriteSideEffect: call to Base | Instruction 'IndirectMayWriteSideEffect' is missing an expected operand with tag 'Address' in function '$@'. | ir.cpp:799:6:799:25 | IR: HierarchyConversions | void HierarchyConversions() | +| ir.cpp:823:7:823:13 | IndirectMayWriteSideEffect: call to Base | Instruction 'IndirectMayWriteSideEffect' is missing an expected operand with tag 'Address' in function '$@'. | ir.cpp:799:6:799:25 | IR: HierarchyConversions | void HierarchyConversions() | +| ir.cpp:824:7:824:26 | IndirectMayWriteSideEffect: call to Base | Instruction 'IndirectMayWriteSideEffect' is missing an expected operand with tag 'Address' in function '$@'. | ir.cpp:799:6:799:25 | IR: HierarchyConversions | void HierarchyConversions() | +unexpectedOperand +duplicateOperand +missingPhiOperand +missingOperandType +duplicateChiOperand +sideEffectWithoutPrimary +instructionWithoutSuccessor +ambiguousSuccessors +unexplainedLoop +unnecessaryPhiInstruction +operandAcrossFunctions +instructionWithoutUniqueBlock +containsLoopOfForwardEdges +lostReachability +backEdgeCountMismatch +useNotDominatedByDefinition +missingCanonicalLanguageType +multipleCanonicalLanguageTypes +missingIRType +multipleIRTypes +missingCppType diff --git a/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_sanity.qlref b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_sanity_unsound.qlref similarity index 100% rename from cpp/ql/test/library-tests/ir/ir/unaliased_ssa_sanity.qlref rename to cpp/ql/test/library-tests/ir/ir/unaliased_ssa_sanity_unsound.qlref diff --git a/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ssa_sanity.ql b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ssa_sanity.ql new file mode 100644 index 00000000000..120881bf018 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ssa_sanity.ql @@ -0,0 +1,2 @@ +import semmle.code.cpp.ir.implementation.unaliased_ssa.internal.SSASanity +import semmle.code.cpp.ir.implementation.UseSoundEscapeAnalysis diff --git a/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ssa_sanity_unsound.expected b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ssa_sanity_unsound.expected new file mode 100644 index 00000000000..7c2d1faf639 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ssa_sanity_unsound.expected @@ -0,0 +1,2 @@ +multipleOperandMemoryLocations +missingVirtualVariableForMemoryLocation diff --git a/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ssa_sanity.qlref b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ssa_sanity_unsound.qlref similarity index 100% rename from cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ssa_sanity.qlref rename to cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ssa_sanity_unsound.qlref diff --git a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir.ql b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir.ql new file mode 100644 index 00000000000..d8b68d0d72e --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir.ql @@ -0,0 +1,6 @@ +/** + * @kind graph + */ + +import semmle.code.cpp.ir.implementation.aliased_ssa.PrintIR +import semmle.code.cpp.ir.implementation.UseSoundEscapeAnalysis diff --git a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir_unsound.expected b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir_unsound.expected new file mode 100644 index 00000000000..6846661b665 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir_unsound.expected @@ -0,0 +1,1082 @@ +ssa.cpp: +# 13| int ChiPhiNode(Point*, bool, bool) +# 13| Block 0 +# 13| v13_1(void) = EnterFunction : +# 13| m13_2(unknown) = AliasedDefinition : +# 13| mu13_3(unknown) = UnmodeledDefinition : +# 13| r13_4(glval) = VariableAddress[p] : +# 13| m13_5(Point *) = InitializeParameter[p] : &:r13_4 +# 13| r13_6(Point *) = Load : &:r13_4, m13_5 +# 13| m13_7(unknown) = InitializeIndirection[p] : &:r13_6 +# 13| m13_8(unknown) = Chi : total:m13_2, partial:m13_7 +# 13| r13_9(glval) = VariableAddress[which1] : +# 13| m13_10(bool) = InitializeParameter[which1] : &:r13_9 +# 13| r13_11(glval) = VariableAddress[which2] : +# 13| m13_12(bool) = InitializeParameter[which2] : &:r13_11 +# 14| r14_1(glval) = VariableAddress[which1] : +# 14| r14_2(bool) = Load : &:r14_1, m13_10 +# 14| v14_3(void) = ConditionalBranch : r14_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 15| Block 1 +# 15| r15_1(glval) = VariableAddress[p] : +# 15| r15_2(Point *) = Load : &:r15_1, m13_5 +# 15| r15_3(glval) = FieldAddress[x] : r15_2 +# 15| r15_4(int) = Load : &:r15_3, ~m13_8 +# 15| r15_5(int) = Constant[1] : +# 15| r15_6(int) = Add : r15_4, r15_5 +# 15| m15_7(int) = Store : &:r15_3, r15_6 +# 15| m15_8(unknown) = Chi : total:m13_8, partial:m15_7 +#-----| Goto -> Block 3 + +# 18| Block 2 +# 18| r18_1(glval) = VariableAddress[p] : +# 18| r18_2(Point *) = Load : &:r18_1, m13_5 +# 18| r18_3(glval) = FieldAddress[y] : r18_2 +# 18| r18_4(int) = Load : &:r18_3, ~m13_8 +# 18| r18_5(int) = Constant[1] : +# 18| r18_6(int) = Add : r18_4, r18_5 +# 18| m18_7(int) = Store : &:r18_3, r18_6 +# 18| m18_8(unknown) = Chi : total:m13_8, partial:m18_7 +#-----| Goto -> Block 3 + +# 21| Block 3 +# 21| m21_1(unknown) = Phi : from 1:~m15_8, from 2:~m18_8 +# 21| r21_2(glval) = VariableAddress[which2] : +# 21| r21_3(bool) = Load : &:r21_2, m13_12 +# 21| v21_4(void) = ConditionalBranch : r21_3 +#-----| False -> Block 5 +#-----| True -> Block 4 + +# 22| Block 4 +# 22| r22_1(glval) = VariableAddress[p] : +# 22| r22_2(Point *) = Load : &:r22_1, m13_5 +# 22| r22_3(glval) = FieldAddress[x] : r22_2 +# 22| r22_4(int) = Load : &:r22_3, ~m21_1 +# 22| r22_5(int) = Constant[1] : +# 22| r22_6(int) = Add : r22_4, r22_5 +# 22| m22_7(int) = Store : &:r22_3, r22_6 +# 22| m22_8(unknown) = Chi : total:m21_1, partial:m22_7 +#-----| Goto -> Block 6 + +# 25| Block 5 +# 25| r25_1(glval) = VariableAddress[p] : +# 25| r25_2(Point *) = Load : &:r25_1, m13_5 +# 25| r25_3(glval) = FieldAddress[y] : r25_2 +# 25| r25_4(int) = Load : &:r25_3, ~m21_1 +# 25| r25_5(int) = Constant[1] : +# 25| r25_6(int) = Add : r25_4, r25_5 +# 25| m25_7(int) = Store : &:r25_3, r25_6 +# 25| m25_8(unknown) = Chi : total:m21_1, partial:m25_7 +#-----| Goto -> Block 6 + +# 28| Block 6 +# 28| m28_1(unknown) = Phi : from 4:~m22_8, from 5:~m25_8 +# 28| r28_2(glval) = VariableAddress[#return] : +# 28| r28_3(glval) = VariableAddress[p] : +# 28| r28_4(Point *) = Load : &:r28_3, m13_5 +# 28| r28_5(glval) = FieldAddress[x] : r28_4 +# 28| r28_6(int) = Load : &:r28_5, ~m28_1 +# 28| r28_7(glval) = VariableAddress[p] : +# 28| r28_8(Point *) = Load : &:r28_7, m13_5 +# 28| r28_9(glval) = FieldAddress[y] : r28_8 +# 28| r28_10(int) = Load : &:r28_9, ~m28_1 +# 28| r28_11(int) = Add : r28_6, r28_10 +# 28| m28_12(int) = Store : &:r28_2, r28_11 +# 13| v13_13(void) = ReturnIndirection : &:r13_6, ~m28_1 +# 13| r13_14(glval) = VariableAddress[#return] : +# 13| v13_15(void) = ReturnValue : &:r13_14, m28_12 +# 13| v13_16(void) = UnmodeledUse : mu* +# 13| v13_17(void) = AliasedUse : ~m28_1 +# 13| v13_18(void) = ExitFunction : + +# 31| int UnreachableViaGoto() +# 31| Block 0 +# 31| v31_1(void) = EnterFunction : +# 31| m31_2(unknown) = AliasedDefinition : +# 31| mu31_3(unknown) = UnmodeledDefinition : +# 32| v32_1(void) = NoOp : +# 34| v34_1(void) = NoOp : +# 35| r35_1(glval) = VariableAddress[#return] : +# 35| r35_2(int) = Constant[0] : +# 35| m35_3(int) = Store : &:r35_1, r35_2 +# 31| r31_4(glval) = VariableAddress[#return] : +# 31| v31_5(void) = ReturnValue : &:r31_4, m35_3 +# 31| v31_6(void) = UnmodeledUse : mu* +# 31| v31_7(void) = AliasedUse : ~m31_2 +# 31| v31_8(void) = ExitFunction : + +# 38| int UnreachableIf(bool) +# 38| Block 0 +# 38| v38_1(void) = EnterFunction : +# 38| m38_2(unknown) = AliasedDefinition : +# 38| mu38_3(unknown) = UnmodeledDefinition : +# 38| r38_4(glval) = VariableAddress[b] : +# 38| m38_5(bool) = InitializeParameter[b] : &:r38_4 +# 39| r39_1(glval) = VariableAddress[x] : +# 39| r39_2(int) = Constant[5] : +# 39| m39_3(int) = Store : &:r39_1, r39_2 +# 40| r40_1(glval) = VariableAddress[y] : +# 40| r40_2(int) = Constant[10] : +# 40| m40_3(int) = Store : &:r40_1, r40_2 +# 41| r41_1(glval) = VariableAddress[b] : +# 41| r41_2(bool) = Load : &:r41_1, m38_5 +# 41| v41_3(void) = ConditionalBranch : r41_2 +#-----| False -> Block 4 +#-----| True -> Block 2 + +# 38| Block 1 +# 38| m38_6(int) = Phi : from 3:m46_3, from 5:m51_3 +# 38| r38_7(glval) = VariableAddress[#return] : +# 38| v38_8(void) = ReturnValue : &:r38_7, m38_6 +# 38| v38_9(void) = UnmodeledUse : mu* +# 38| v38_10(void) = AliasedUse : ~m38_2 +# 38| v38_11(void) = ExitFunction : + +# 42| Block 2 +# 42| r42_1(glval) = VariableAddress[x] : +# 42| r42_2(int) = Load : &:r42_1, m39_3 +# 42| r42_3(glval) = VariableAddress[y] : +# 42| r42_4(int) = Load : &:r42_3, m40_3 +# 42| r42_5(bool) = CompareEQ : r42_2, r42_4 +# 42| v42_6(void) = ConditionalBranch : r42_5 +#-----| False -> Block 3 +#-----| True -> Block 6 + +# 46| Block 3 +# 46| r46_1(glval) = VariableAddress[#return] : +# 46| r46_2(int) = Constant[0] : +# 46| m46_3(int) = Store : &:r46_1, r46_2 +#-----| Goto -> Block 1 + +# 50| Block 4 +# 50| r50_1(glval) = VariableAddress[x] : +# 50| r50_2(int) = Load : &:r50_1, m39_3 +# 50| r50_3(glval) = VariableAddress[y] : +# 50| r50_4(int) = Load : &:r50_3, m40_3 +# 50| r50_5(bool) = CompareLT : r50_2, r50_4 +# 50| v50_6(void) = ConditionalBranch : r50_5 +#-----| False -> Block 6 +#-----| True -> Block 5 + +# 51| Block 5 +# 51| r51_1(glval) = VariableAddress[#return] : +# 51| r51_2(int) = Constant[0] : +# 51| m51_3(int) = Store : &:r51_1, r51_2 +#-----| Goto -> Block 1 + +# 38| Block 6 +# 38| v38_12(void) = Unreached : + +# 59| int DoWhileFalse() +# 59| Block 0 +# 59| v59_1(void) = EnterFunction : +# 59| m59_2(unknown) = AliasedDefinition : +# 59| mu59_3(unknown) = UnmodeledDefinition : +# 60| r60_1(glval) = VariableAddress[i] : +# 60| r60_2(int) = Constant[0] : +# 60| m60_3(int) = Store : &:r60_1, r60_2 +# 62| r62_1(glval) = VariableAddress[i] : +# 62| r62_2(int) = Load : &:r62_1, m60_3 +# 62| r62_3(int) = Constant[1] : +# 62| r62_4(int) = Add : r62_2, r62_3 +# 62| m62_5(int) = Store : &:r62_1, r62_4 +# 63| r63_1(bool) = Constant[0] : +# 63| v63_2(void) = ConditionalBranch : r63_1 +#-----| False -> Block 1 +#-----| True -> Block 2 + +# 65| Block 1 +# 65| r65_1(glval) = VariableAddress[#return] : +# 65| r65_2(glval) = VariableAddress[i] : +# 65| r65_3(int) = Load : &:r65_2, m62_5 +# 65| m65_4(int) = Store : &:r65_1, r65_3 +# 59| r59_4(glval) = VariableAddress[#return] : +# 59| v59_5(void) = ReturnValue : &:r59_4, m65_4 +# 59| v59_6(void) = UnmodeledUse : mu* +# 59| v59_7(void) = AliasedUse : ~m59_2 +# 59| v59_8(void) = ExitFunction : + +# 59| Block 2 +# 59| v59_9(void) = Unreached : + +# 68| void chiNodeAtEndOfLoop(int, char*) +# 68| Block 0 +# 68| v68_1(void) = EnterFunction : +# 68| m68_2(unknown) = AliasedDefinition : +# 68| mu68_3(unknown) = UnmodeledDefinition : +# 68| r68_4(glval) = VariableAddress[n] : +# 68| m68_5(int) = InitializeParameter[n] : &:r68_4 +# 68| r68_6(glval) = VariableAddress[p] : +# 68| m68_7(char *) = InitializeParameter[p] : &:r68_6 +# 68| r68_8(char *) = Load : &:r68_6, m68_7 +# 68| m68_9(unknown) = InitializeIndirection[p] : &:r68_8 +# 68| m68_10(unknown) = Chi : total:m68_2, partial:m68_9 +#-----| Goto -> Block 3 + +# 70| Block 1 +# 70| r70_1(char) = Constant[0] : +# 70| r70_2(glval) = VariableAddress[p] : +# 70| r70_3(char *) = Load : &:r70_2, m69_1 +# 70| r70_4(int) = Constant[1] : +# 70| r70_5(char *) = PointerAdd[1] : r70_3, r70_4 +# 70| m70_6(char *) = Store : &:r70_2, r70_5 +# 70| r70_7(glval) = CopyValue : r70_3 +# 70| m70_8(char) = Store : &:r70_7, r70_1 +# 70| m70_9(unknown) = Chi : total:m69_3, partial:m70_8 +#-----| Goto (back edge) -> Block 3 + +# 71| Block 2 +# 71| v71_1(void) = NoOp : +# 68| v68_11(void) = ReturnIndirection : &:r68_8, ~m69_3 +# 68| v68_12(void) = ReturnVoid : +# 68| v68_13(void) = UnmodeledUse : mu* +# 68| v68_14(void) = AliasedUse : ~m69_3 +# 68| v68_15(void) = ExitFunction : + +# 69| Block 3 +# 69| m69_1(char *) = Phi : from 0:m68_7, from 1:m70_6 +# 69| m69_2(int) = Phi : from 0:m68_5, from 1:m69_8 +# 69| m69_3(unknown) = Phi : from 0:~m68_10, from 1:~m70_9 +# 69| r69_4(glval) = VariableAddress[n] : +# 69| r69_5(int) = Load : &:r69_4, m69_2 +# 69| r69_6(int) = Constant[1] : +# 69| r69_7(int) = Sub : r69_5, r69_6 +# 69| m69_8(int) = Store : &:r69_4, r69_7 +# 69| r69_9(int) = Constant[0] : +# 69| r69_10(bool) = CompareGT : r69_5, r69_9 +# 69| v69_11(void) = ConditionalBranch : r69_10 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 75| void ScalarPhi(bool) +# 75| Block 0 +# 75| v75_1(void) = EnterFunction : +# 75| m75_2(unknown) = AliasedDefinition : +# 75| mu75_3(unknown) = UnmodeledDefinition : +# 75| r75_4(glval) = VariableAddress[b] : +# 75| m75_5(bool) = InitializeParameter[b] : &:r75_4 +# 76| r76_1(glval) = VariableAddress[x] : +# 76| r76_2(int) = Constant[0] : +# 76| m76_3(int) = Store : &:r76_1, r76_2 +# 77| r77_1(glval) = VariableAddress[y] : +# 77| r77_2(int) = Constant[1] : +# 77| m77_3(int) = Store : &:r77_1, r77_2 +# 78| r78_1(glval) = VariableAddress[z] : +# 78| r78_2(int) = Constant[2] : +# 78| m78_3(int) = Store : &:r78_1, r78_2 +# 79| r79_1(glval) = VariableAddress[b] : +# 79| r79_2(bool) = Load : &:r79_1, m75_5 +# 79| v79_3(void) = ConditionalBranch : r79_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 80| Block 1 +# 80| r80_1(int) = Constant[3] : +# 80| r80_2(glval) = VariableAddress[x] : +# 80| m80_3(int) = Store : &:r80_2, r80_1 +# 81| r81_1(int) = Constant[4] : +# 81| r81_2(glval) = VariableAddress[y] : +# 81| m81_3(int) = Store : &:r81_2, r81_1 +#-----| Goto -> Block 3 + +# 84| Block 2 +# 84| r84_1(int) = Constant[5] : +# 84| r84_2(glval) = VariableAddress[x] : +# 84| m84_3(int) = Store : &:r84_2, r84_1 +#-----| Goto -> Block 3 + +# 86| Block 3 +# 86| m86_1(int) = Phi : from 1:m81_3, from 2:m77_3 +# 86| m86_2(int) = Phi : from 1:m80_3, from 2:m84_3 +# 86| r86_3(glval) = VariableAddress[x_merge] : +# 86| r86_4(glval) = VariableAddress[x] : +# 86| r86_5(int) = Load : &:r86_4, m86_2 +# 86| m86_6(int) = Store : &:r86_3, r86_5 +# 87| r87_1(glval) = VariableAddress[y_merge] : +# 87| r87_2(glval) = VariableAddress[y] : +# 87| r87_3(int) = Load : &:r87_2, m86_1 +# 87| m87_4(int) = Store : &:r87_1, r87_3 +# 88| r88_1(glval) = VariableAddress[z_merge] : +# 88| r88_2(glval) = VariableAddress[z] : +# 88| r88_3(int) = Load : &:r88_2, m78_3 +# 88| m88_4(int) = Store : &:r88_1, r88_3 +# 89| v89_1(void) = NoOp : +# 75| v75_6(void) = ReturnVoid : +# 75| v75_7(void) = UnmodeledUse : mu* +# 75| v75_8(void) = AliasedUse : ~m75_2 +# 75| v75_9(void) = ExitFunction : + +# 91| void MustExactlyOverlap(Point) +# 91| Block 0 +# 91| v91_1(void) = EnterFunction : +# 91| m91_2(unknown) = AliasedDefinition : +# 91| mu91_3(unknown) = UnmodeledDefinition : +# 91| r91_4(glval) = VariableAddress[a] : +# 91| m91_5(Point) = InitializeParameter[a] : &:r91_4 +# 92| r92_1(glval) = VariableAddress[b] : +# 92| r92_2(glval) = VariableAddress[a] : +# 92| r92_3(Point) = Load : &:r92_2, m91_5 +# 92| m92_4(Point) = Store : &:r92_1, r92_3 +# 93| v93_1(void) = NoOp : +# 91| v91_6(void) = ReturnVoid : +# 91| v91_7(void) = UnmodeledUse : mu* +# 91| v91_8(void) = AliasedUse : ~m91_2 +# 91| v91_9(void) = ExitFunction : + +# 95| void MustExactlyOverlapEscaped(Point) +# 95| Block 0 +# 95| v95_1(void) = EnterFunction : +# 95| m95_2(unknown) = AliasedDefinition : +# 95| mu95_3(unknown) = UnmodeledDefinition : +# 95| r95_4(glval) = VariableAddress[a] : +# 95| m95_5(Point) = InitializeParameter[a] : &:r95_4 +# 96| r96_1(glval) = VariableAddress[b] : +# 96| r96_2(glval) = VariableAddress[a] : +# 96| r96_3(Point) = Load : &:r96_2, m95_5 +# 96| m96_4(Point) = Store : &:r96_1, r96_3 +# 97| r97_1(glval) = FunctionAddress[Escape] : +# 97| r97_2(glval) = VariableAddress[a] : +# 97| r97_3(Point *) = CopyValue : r97_2 +# 97| r97_4(void *) = Convert : r97_3 +# 97| v97_5(void) = Call : func:r97_1, 0:r97_4 +# 97| m97_6(unknown) = ^CallSideEffect : ~m95_2 +# 97| m97_7(unknown) = Chi : total:m95_2, partial:m97_6 +# 97| v97_8(void) = ^BufferReadSideEffect[0] : &:r97_4, ~m95_5 +# 97| m97_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r97_4 +# 97| m97_10(Point) = Chi : total:m95_5, partial:m97_9 +# 98| v98_1(void) = NoOp : +# 95| v95_6(void) = ReturnVoid : +# 95| v95_7(void) = UnmodeledUse : mu* +# 95| v95_8(void) = AliasedUse : ~m97_7 +# 95| v95_9(void) = ExitFunction : + +# 100| void MustTotallyOverlap(Point) +# 100| Block 0 +# 100| v100_1(void) = EnterFunction : +# 100| m100_2(unknown) = AliasedDefinition : +# 100| mu100_3(unknown) = UnmodeledDefinition : +# 100| r100_4(glval) = VariableAddress[a] : +# 100| m100_5(Point) = InitializeParameter[a] : &:r100_4 +# 101| r101_1(glval) = VariableAddress[x] : +# 101| r101_2(glval) = VariableAddress[a] : +# 101| r101_3(glval) = FieldAddress[x] : r101_2 +# 101| r101_4(int) = Load : &:r101_3, ~m100_5 +# 101| m101_5(int) = Store : &:r101_1, r101_4 +# 102| r102_1(glval) = VariableAddress[y] : +# 102| r102_2(glval) = VariableAddress[a] : +# 102| r102_3(glval) = FieldAddress[y] : r102_2 +# 102| r102_4(int) = Load : &:r102_3, ~m100_5 +# 102| m102_5(int) = Store : &:r102_1, r102_4 +# 103| v103_1(void) = NoOp : +# 100| v100_6(void) = ReturnVoid : +# 100| v100_7(void) = UnmodeledUse : mu* +# 100| v100_8(void) = AliasedUse : ~m100_2 +# 100| v100_9(void) = ExitFunction : + +# 105| void MustTotallyOverlapEscaped(Point) +# 105| Block 0 +# 105| v105_1(void) = EnterFunction : +# 105| m105_2(unknown) = AliasedDefinition : +# 105| mu105_3(unknown) = UnmodeledDefinition : +# 105| r105_4(glval) = VariableAddress[a] : +# 105| m105_5(Point) = InitializeParameter[a] : &:r105_4 +# 106| r106_1(glval) = VariableAddress[x] : +# 106| r106_2(glval) = VariableAddress[a] : +# 106| r106_3(glval) = FieldAddress[x] : r106_2 +# 106| r106_4(int) = Load : &:r106_3, ~m105_5 +# 106| m106_5(int) = Store : &:r106_1, r106_4 +# 107| r107_1(glval) = VariableAddress[y] : +# 107| r107_2(glval) = VariableAddress[a] : +# 107| r107_3(glval) = FieldAddress[y] : r107_2 +# 107| r107_4(int) = Load : &:r107_3, ~m105_5 +# 107| m107_5(int) = Store : &:r107_1, r107_4 +# 108| r108_1(glval) = FunctionAddress[Escape] : +# 108| r108_2(glval) = VariableAddress[a] : +# 108| r108_3(Point *) = CopyValue : r108_2 +# 108| r108_4(void *) = Convert : r108_3 +# 108| v108_5(void) = Call : func:r108_1, 0:r108_4 +# 108| m108_6(unknown) = ^CallSideEffect : ~m105_2 +# 108| m108_7(unknown) = Chi : total:m105_2, partial:m108_6 +# 108| v108_8(void) = ^BufferReadSideEffect[0] : &:r108_4, ~m105_5 +# 108| m108_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r108_4 +# 108| m108_10(Point) = Chi : total:m105_5, partial:m108_9 +# 109| v109_1(void) = NoOp : +# 105| v105_6(void) = ReturnVoid : +# 105| v105_7(void) = UnmodeledUse : mu* +# 105| v105_8(void) = AliasedUse : ~m108_7 +# 105| v105_9(void) = ExitFunction : + +# 111| void MayPartiallyOverlap(int, int) +# 111| Block 0 +# 111| v111_1(void) = EnterFunction : +# 111| m111_2(unknown) = AliasedDefinition : +# 111| mu111_3(unknown) = UnmodeledDefinition : +# 111| r111_4(glval) = VariableAddress[x] : +# 111| m111_5(int) = InitializeParameter[x] : &:r111_4 +# 111| r111_6(glval) = VariableAddress[y] : +# 111| m111_7(int) = InitializeParameter[y] : &:r111_6 +# 112| r112_1(glval) = VariableAddress[a] : +# 112| m112_2(Point) = Uninitialized[a] : &:r112_1 +# 112| r112_3(glval) = FieldAddress[x] : r112_1 +# 112| r112_4(glval) = VariableAddress[x] : +# 112| r112_5(int) = Load : &:r112_4, m111_5 +# 112| m112_6(int) = Store : &:r112_3, r112_5 +# 112| m112_7(Point) = Chi : total:m112_2, partial:m112_6 +# 112| r112_8(glval) = FieldAddress[y] : r112_1 +# 112| r112_9(glval) = VariableAddress[y] : +# 112| r112_10(int) = Load : &:r112_9, m111_7 +# 112| m112_11(int) = Store : &:r112_8, r112_10 +# 112| m112_12(Point) = Chi : total:m112_7, partial:m112_11 +# 113| r113_1(glval) = VariableAddress[b] : +# 113| r113_2(glval) = VariableAddress[a] : +# 113| r113_3(Point) = Load : &:r113_2, ~m112_12 +# 113| m113_4(Point) = Store : &:r113_1, r113_3 +# 114| v114_1(void) = NoOp : +# 111| v111_8(void) = ReturnVoid : +# 111| v111_9(void) = UnmodeledUse : mu* +# 111| v111_10(void) = AliasedUse : ~m111_2 +# 111| v111_11(void) = ExitFunction : + +# 116| void MayPartiallyOverlapEscaped(int, int) +# 116| Block 0 +# 116| v116_1(void) = EnterFunction : +# 116| m116_2(unknown) = AliasedDefinition : +# 116| mu116_3(unknown) = UnmodeledDefinition : +# 116| r116_4(glval) = VariableAddress[x] : +# 116| m116_5(int) = InitializeParameter[x] : &:r116_4 +# 116| r116_6(glval) = VariableAddress[y] : +# 116| m116_7(int) = InitializeParameter[y] : &:r116_6 +# 117| r117_1(glval) = VariableAddress[a] : +# 117| m117_2(Point) = Uninitialized[a] : &:r117_1 +# 117| r117_3(glval) = FieldAddress[x] : r117_1 +# 117| r117_4(glval) = VariableAddress[x] : +# 117| r117_5(int) = Load : &:r117_4, m116_5 +# 117| m117_6(int) = Store : &:r117_3, r117_5 +# 117| m117_7(Point) = Chi : total:m117_2, partial:m117_6 +# 117| r117_8(glval) = FieldAddress[y] : r117_1 +# 117| r117_9(glval) = VariableAddress[y] : +# 117| r117_10(int) = Load : &:r117_9, m116_7 +# 117| m117_11(int) = Store : &:r117_8, r117_10 +# 117| m117_12(Point) = Chi : total:m117_7, partial:m117_11 +# 118| r118_1(glval) = VariableAddress[b] : +# 118| r118_2(glval) = VariableAddress[a] : +# 118| r118_3(Point) = Load : &:r118_2, ~m117_12 +# 118| m118_4(Point) = Store : &:r118_1, r118_3 +# 119| r119_1(glval) = FunctionAddress[Escape] : +# 119| r119_2(glval) = VariableAddress[a] : +# 119| r119_3(Point *) = CopyValue : r119_2 +# 119| r119_4(void *) = Convert : r119_3 +# 119| v119_5(void) = Call : func:r119_1, 0:r119_4 +# 119| m119_6(unknown) = ^CallSideEffect : ~m116_2 +# 119| m119_7(unknown) = Chi : total:m116_2, partial:m119_6 +# 119| v119_8(void) = ^BufferReadSideEffect[0] : &:r119_4, ~m117_12 +# 119| m119_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r119_4 +# 119| m119_10(Point) = Chi : total:m117_12, partial:m119_9 +# 120| v120_1(void) = NoOp : +# 116| v116_8(void) = ReturnVoid : +# 116| v116_9(void) = UnmodeledUse : mu* +# 116| v116_10(void) = AliasedUse : ~m119_7 +# 116| v116_11(void) = ExitFunction : + +# 122| void MergeMustExactlyOverlap(bool, int, int) +# 122| Block 0 +# 122| v122_1(void) = EnterFunction : +# 122| m122_2(unknown) = AliasedDefinition : +# 122| mu122_3(unknown) = UnmodeledDefinition : +# 122| r122_4(glval) = VariableAddress[c] : +# 122| m122_5(bool) = InitializeParameter[c] : &:r122_4 +# 122| r122_6(glval) = VariableAddress[x1] : +# 122| m122_7(int) = InitializeParameter[x1] : &:r122_6 +# 122| r122_8(glval) = VariableAddress[x2] : +# 122| m122_9(int) = InitializeParameter[x2] : &:r122_8 +# 123| r123_1(glval) = VariableAddress[a] : +# 123| m123_2(Point) = Uninitialized[a] : &:r123_1 +# 123| r123_3(glval) = FieldAddress[x] : r123_1 +# 123| r123_4(int) = Constant[0] : +# 123| m123_5(int) = Store : &:r123_3, r123_4 +# 123| m123_6(Point) = Chi : total:m123_2, partial:m123_5 +# 123| r123_7(glval) = FieldAddress[y] : r123_1 +# 123| r123_8(int) = Constant[0] : +# 123| m123_9(int) = Store : &:r123_7, r123_8 +# 123| m123_10(Point) = Chi : total:m123_6, partial:m123_9 +# 124| r124_1(glval) = VariableAddress[c] : +# 124| r124_2(bool) = Load : &:r124_1, m122_5 +# 124| v124_3(void) = ConditionalBranch : r124_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 125| Block 1 +# 125| r125_1(glval) = VariableAddress[x1] : +# 125| r125_2(int) = Load : &:r125_1, m122_7 +# 125| r125_3(glval) = VariableAddress[a] : +# 125| r125_4(glval) = FieldAddress[x] : r125_3 +# 125| m125_5(int) = Store : &:r125_4, r125_2 +# 125| m125_6(Point) = Chi : total:m123_10, partial:m125_5 +#-----| Goto -> Block 3 + +# 128| Block 2 +# 128| r128_1(glval) = VariableAddress[x2] : +# 128| r128_2(int) = Load : &:r128_1, m122_9 +# 128| r128_3(glval) = VariableAddress[a] : +# 128| r128_4(glval) = FieldAddress[x] : r128_3 +# 128| m128_5(int) = Store : &:r128_4, r128_2 +# 128| m128_6(Point) = Chi : total:m123_10, partial:m128_5 +#-----| Goto -> Block 3 + +# 130| Block 3 +# 130| m130_1(int) = Phi : from 1:m125_5, from 2:m128_5 +# 130| m130_2(Point) = Phi : from 1:m125_6, from 2:m128_6 +# 130| r130_3(glval) = VariableAddress[x] : +# 130| r130_4(glval) = VariableAddress[a] : +# 130| r130_5(glval) = FieldAddress[x] : r130_4 +# 130| r130_6(int) = Load : &:r130_5, m130_1 +# 130| m130_7(int) = Store : &:r130_3, r130_6 +# 131| r131_1(glval) = VariableAddress[b] : +# 131| r131_2(glval) = VariableAddress[a] : +# 131| r131_3(Point) = Load : &:r131_2, m130_2 +# 131| m131_4(Point) = Store : &:r131_1, r131_3 +# 132| v132_1(void) = NoOp : +# 122| v122_10(void) = ReturnVoid : +# 122| v122_11(void) = UnmodeledUse : mu* +# 122| v122_12(void) = AliasedUse : ~m122_2 +# 122| v122_13(void) = ExitFunction : + +# 134| void MergeMustExactlyWithMustTotallyOverlap(bool, Point, int) +# 134| Block 0 +# 134| v134_1(void) = EnterFunction : +# 134| m134_2(unknown) = AliasedDefinition : +# 134| mu134_3(unknown) = UnmodeledDefinition : +# 134| r134_4(glval) = VariableAddress[c] : +# 134| m134_5(bool) = InitializeParameter[c] : &:r134_4 +# 134| r134_6(glval) = VariableAddress[p] : +# 134| m134_7(Point) = InitializeParameter[p] : &:r134_6 +# 134| r134_8(glval) = VariableAddress[x1] : +# 134| m134_9(int) = InitializeParameter[x1] : &:r134_8 +# 135| r135_1(glval) = VariableAddress[a] : +# 135| m135_2(Point) = Uninitialized[a] : &:r135_1 +# 135| r135_3(glval) = FieldAddress[x] : r135_1 +# 135| r135_4(int) = Constant[0] : +# 135| m135_5(int) = Store : &:r135_3, r135_4 +# 135| m135_6(Point) = Chi : total:m135_2, partial:m135_5 +# 135| r135_7(glval) = FieldAddress[y] : r135_1 +# 135| r135_8(int) = Constant[0] : +# 135| m135_9(int) = Store : &:r135_7, r135_8 +# 135| m135_10(Point) = Chi : total:m135_6, partial:m135_9 +# 136| r136_1(glval) = VariableAddress[c] : +# 136| r136_2(bool) = Load : &:r136_1, m134_5 +# 136| v136_3(void) = ConditionalBranch : r136_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 137| Block 1 +# 137| r137_1(glval) = VariableAddress[x1] : +# 137| r137_2(int) = Load : &:r137_1, m134_9 +# 137| r137_3(glval) = VariableAddress[a] : +# 137| r137_4(glval) = FieldAddress[x] : r137_3 +# 137| m137_5(int) = Store : &:r137_4, r137_2 +# 137| m137_6(Point) = Chi : total:m135_10, partial:m137_5 +#-----| Goto -> Block 3 + +# 140| Block 2 +# 140| r140_1(glval) = VariableAddress[p] : +# 140| r140_2(Point) = Load : &:r140_1, m134_7 +# 140| r140_3(glval) = VariableAddress[a] : +# 140| m140_4(Point) = Store : &:r140_3, r140_2 +#-----| Goto -> Block 3 + +# 142| Block 3 +# 142| m142_1(int) = Phi : from 1:m137_5, from 2:~m140_4 +# 142| m142_2(Point) = Phi : from 1:m137_6, from 2:m140_4 +# 142| r142_3(glval) = VariableAddress[x] : +# 142| r142_4(glval) = VariableAddress[a] : +# 142| r142_5(glval) = FieldAddress[x] : r142_4 +# 142| r142_6(int) = Load : &:r142_5, m142_1 +# 142| m142_7(int) = Store : &:r142_3, r142_6 +# 143| v143_1(void) = NoOp : +# 134| v134_10(void) = ReturnVoid : +# 134| v134_11(void) = UnmodeledUse : mu* +# 134| v134_12(void) = AliasedUse : ~m134_2 +# 134| v134_13(void) = ExitFunction : + +# 145| void MergeMustExactlyWithMayPartiallyOverlap(bool, Point, int) +# 145| Block 0 +# 145| v145_1(void) = EnterFunction : +# 145| m145_2(unknown) = AliasedDefinition : +# 145| mu145_3(unknown) = UnmodeledDefinition : +# 145| r145_4(glval) = VariableAddress[c] : +# 145| m145_5(bool) = InitializeParameter[c] : &:r145_4 +# 145| r145_6(glval) = VariableAddress[p] : +# 145| m145_7(Point) = InitializeParameter[p] : &:r145_6 +# 145| r145_8(glval) = VariableAddress[x1] : +# 145| m145_9(int) = InitializeParameter[x1] : &:r145_8 +# 146| r146_1(glval) = VariableAddress[a] : +# 146| m146_2(Point) = Uninitialized[a] : &:r146_1 +# 146| r146_3(glval) = FieldAddress[x] : r146_1 +# 146| r146_4(int) = Constant[0] : +# 146| m146_5(int) = Store : &:r146_3, r146_4 +# 146| m146_6(Point) = Chi : total:m146_2, partial:m146_5 +# 146| r146_7(glval) = FieldAddress[y] : r146_1 +# 146| r146_8(int) = Constant[0] : +# 146| m146_9(int) = Store : &:r146_7, r146_8 +# 146| m146_10(Point) = Chi : total:m146_6, partial:m146_9 +# 147| r147_1(glval) = VariableAddress[c] : +# 147| r147_2(bool) = Load : &:r147_1, m145_5 +# 147| v147_3(void) = ConditionalBranch : r147_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 148| Block 1 +# 148| r148_1(glval) = VariableAddress[x1] : +# 148| r148_2(int) = Load : &:r148_1, m145_9 +# 148| r148_3(glval) = VariableAddress[a] : +# 148| r148_4(glval) = FieldAddress[x] : r148_3 +# 148| m148_5(int) = Store : &:r148_4, r148_2 +# 148| m148_6(Point) = Chi : total:m146_10, partial:m148_5 +#-----| Goto -> Block 3 + +# 151| Block 2 +# 151| r151_1(glval) = VariableAddress[p] : +# 151| r151_2(Point) = Load : &:r151_1, m145_7 +# 151| r151_3(glval) = VariableAddress[a] : +# 151| m151_4(Point) = Store : &:r151_3, r151_2 +#-----| Goto -> Block 3 + +# 153| Block 3 +# 153| m153_1(Point) = Phi : from 1:m148_6, from 2:m151_4 +# 153| r153_2(glval) = VariableAddress[b] : +# 153| r153_3(glval) = VariableAddress[a] : +# 153| r153_4(Point) = Load : &:r153_3, m153_1 +# 153| m153_5(Point) = Store : &:r153_2, r153_4 +# 154| v154_1(void) = NoOp : +# 145| v145_10(void) = ReturnVoid : +# 145| v145_11(void) = UnmodeledUse : mu* +# 145| v145_12(void) = AliasedUse : ~m145_2 +# 145| v145_13(void) = ExitFunction : + +# 156| void MergeMustTotallyOverlapWithMayPartiallyOverlap(bool, Rect, int) +# 156| Block 0 +# 156| v156_1(void) = EnterFunction : +# 156| m156_2(unknown) = AliasedDefinition : +# 156| mu156_3(unknown) = UnmodeledDefinition : +# 156| r156_4(glval) = VariableAddress[c] : +# 156| m156_5(bool) = InitializeParameter[c] : &:r156_4 +# 156| r156_6(glval) = VariableAddress[r] : +# 156| m156_7(Rect) = InitializeParameter[r] : &:r156_6 +# 156| r156_8(glval) = VariableAddress[x1] : +# 156| m156_9(int) = InitializeParameter[x1] : &:r156_8 +# 157| r157_1(glval) = VariableAddress[a] : +# 157| m157_2(Rect) = Uninitialized[a] : &:r157_1 +# 157| r157_3(glval) = FieldAddress[topLeft] : r157_1 +# 157| r157_4(Point) = Constant[0] : +# 157| m157_5(Point) = Store : &:r157_3, r157_4 +# 157| m157_6(Rect) = Chi : total:m157_2, partial:m157_5 +# 157| r157_7(glval) = FieldAddress[bottomRight] : r157_1 +# 157| r157_8(Point) = Constant[0] : +# 157| m157_9(Point) = Store : &:r157_7, r157_8 +# 157| m157_10(Rect) = Chi : total:m157_6, partial:m157_9 +# 158| r158_1(glval) = VariableAddress[c] : +# 158| r158_2(bool) = Load : &:r158_1, m156_5 +# 158| v158_3(void) = ConditionalBranch : r158_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 159| Block 1 +# 159| r159_1(glval) = VariableAddress[x1] : +# 159| r159_2(int) = Load : &:r159_1, m156_9 +# 159| r159_3(glval) = VariableAddress[a] : +# 159| r159_4(glval) = FieldAddress[topLeft] : r159_3 +# 159| r159_5(glval) = FieldAddress[x] : r159_4 +# 159| m159_6(int) = Store : &:r159_5, r159_2 +# 159| m159_7(Rect) = Chi : total:m157_10, partial:m159_6 +#-----| Goto -> Block 3 + +# 162| Block 2 +# 162| r162_1(glval) = VariableAddress[r] : +# 162| r162_2(Rect) = Load : &:r162_1, m156_7 +# 162| r162_3(glval) = VariableAddress[a] : +# 162| m162_4(Rect) = Store : &:r162_3, r162_2 +#-----| Goto -> Block 3 + +# 164| Block 3 +# 164| m164_1(Rect) = Phi : from 1:m159_7, from 2:m162_4 +# 164| r164_2(glval) = VariableAddress[b] : +# 164| r164_3(glval) = VariableAddress[a] : +# 164| r164_4(glval) = FieldAddress[topLeft] : r164_3 +# 164| r164_5(Point) = Load : &:r164_4, ~m164_1 +# 164| m164_6(Point) = Store : &:r164_2, r164_5 +# 165| v165_1(void) = NoOp : +# 156| v156_10(void) = ReturnVoid : +# 156| v156_11(void) = UnmodeledUse : mu* +# 156| v156_12(void) = AliasedUse : ~m156_2 +# 156| v156_13(void) = ExitFunction : + +# 171| void WrapperStruct(Wrapper) +# 171| Block 0 +# 171| v171_1(void) = EnterFunction : +# 171| m171_2(unknown) = AliasedDefinition : +# 171| mu171_3(unknown) = UnmodeledDefinition : +# 171| r171_4(glval) = VariableAddress[w] : +# 171| m171_5(Wrapper) = InitializeParameter[w] : &:r171_4 +# 172| r172_1(glval) = VariableAddress[x] : +# 172| r172_2(glval) = VariableAddress[w] : +# 172| r172_3(Wrapper) = Load : &:r172_2, m171_5 +# 172| m172_4(Wrapper) = Store : &:r172_1, r172_3 +# 173| r173_1(glval) = VariableAddress[a] : +# 173| r173_2(glval) = VariableAddress[w] : +# 173| r173_3(glval) = FieldAddress[f] : r173_2 +# 173| r173_4(int) = Load : &:r173_3, ~m171_5 +# 173| m173_5(int) = Store : &:r173_1, r173_4 +# 174| r174_1(int) = Constant[5] : +# 174| r174_2(glval) = VariableAddress[w] : +# 174| r174_3(glval) = FieldAddress[f] : r174_2 +# 174| m174_4(int) = Store : &:r174_3, r174_1 +# 175| r175_1(glval) = VariableAddress[w] : +# 175| r175_2(glval) = FieldAddress[f] : r175_1 +# 175| r175_3(int) = Load : &:r175_2, m174_4 +# 175| r175_4(glval) = VariableAddress[a] : +# 175| m175_5(int) = Store : &:r175_4, r175_3 +# 176| r176_1(glval) = VariableAddress[w] : +# 176| r176_2(Wrapper) = Load : &:r176_1, ~m174_4 +# 176| r176_3(glval) = VariableAddress[x] : +# 176| m176_4(Wrapper) = Store : &:r176_3, r176_2 +# 177| v177_1(void) = NoOp : +# 171| v171_6(void) = ReturnVoid : +# 171| v171_7(void) = UnmodeledUse : mu* +# 171| v171_8(void) = AliasedUse : ~m171_2 +# 171| v171_9(void) = ExitFunction : + +# 179| int AsmStmt(int*) +# 179| Block 0 +# 179| v179_1(void) = EnterFunction : +# 179| m179_2(unknown) = AliasedDefinition : +# 179| mu179_3(unknown) = UnmodeledDefinition : +# 179| r179_4(glval) = VariableAddress[p] : +# 179| m179_5(int *) = InitializeParameter[p] : &:r179_4 +# 179| r179_6(int *) = Load : &:r179_4, m179_5 +# 179| m179_7(unknown) = InitializeIndirection[p] : &:r179_6 +# 179| m179_8(unknown) = Chi : total:m179_2, partial:m179_7 +# 180| m180_1(unknown) = InlineAsm : ~m179_8 +# 180| m180_2(unknown) = Chi : total:m179_8, partial:m180_1 +# 181| r181_1(glval) = VariableAddress[#return] : +# 181| r181_2(glval) = VariableAddress[p] : +# 181| r181_3(int *) = Load : &:r181_2, m179_5 +# 181| r181_4(int) = Load : &:r181_3, ~m180_2 +# 181| m181_5(int) = Store : &:r181_1, r181_4 +# 179| v179_9(void) = ReturnIndirection : &:r179_6, ~m180_2 +# 179| r179_10(glval) = VariableAddress[#return] : +# 179| v179_11(void) = ReturnValue : &:r179_10, m181_5 +# 179| v179_12(void) = UnmodeledUse : mu* +# 179| v179_13(void) = AliasedUse : ~m180_2 +# 179| v179_14(void) = ExitFunction : + +# 184| void AsmStmtWithOutputs(unsigned int&, unsigned int&, unsigned int&, unsigned int&) +# 184| Block 0 +# 184| v184_1(void) = EnterFunction : +# 184| m184_2(unknown) = AliasedDefinition : +# 184| mu184_3(unknown) = UnmodeledDefinition : +# 184| r184_4(glval) = VariableAddress[a] : +# 184| m184_5(unsigned int &) = InitializeParameter[a] : &:r184_4 +# 184| r184_6(unsigned int &) = Load : &:r184_4, m184_5 +# 184| m184_7(unknown) = InitializeIndirection[a] : &:r184_6 +# 184| m184_8(unknown) = Chi : total:m184_2, partial:m184_7 +# 184| r184_9(glval) = VariableAddress[b] : +# 184| m184_10(unsigned int &) = InitializeParameter[b] : &:r184_9 +# 184| r184_11(unsigned int &) = Load : &:r184_9, m184_10 +# 184| m184_12(unknown) = InitializeIndirection[b] : &:r184_11 +# 184| m184_13(unknown) = Chi : total:m184_8, partial:m184_12 +# 184| r184_14(glval) = VariableAddress[c] : +# 184| m184_15(unsigned int &) = InitializeParameter[c] : &:r184_14 +# 184| r184_16(unsigned int &) = Load : &:r184_14, m184_15 +# 184| m184_17(unknown) = InitializeIndirection[c] : &:r184_16 +# 184| m184_18(unknown) = Chi : total:m184_13, partial:m184_17 +# 184| r184_19(glval) = VariableAddress[d] : +# 184| m184_20(unsigned int &) = InitializeParameter[d] : &:r184_19 +# 184| r184_21(unsigned int &) = Load : &:r184_19, m184_20 +# 184| m184_22(unknown) = InitializeIndirection[d] : &:r184_21 +# 184| m184_23(unknown) = Chi : total:m184_18, partial:m184_22 +# 189| r189_1(glval) = VariableAddress[a] : +# 189| r189_2(unsigned int &) = Load : &:r189_1, m184_5 +# 189| r189_3(glval) = CopyValue : r189_2 +# 189| r189_4(glval) = VariableAddress[b] : +# 189| r189_5(unsigned int &) = Load : &:r189_4, m184_10 +# 189| r189_6(glval) = CopyValue : r189_5 +# 190| r190_1(glval) = VariableAddress[c] : +# 190| r190_2(unsigned int &) = Load : &:r190_1, m184_15 +# 190| r190_3(unsigned int) = Load : &:r190_2, ~m184_23 +# 190| r190_4(glval) = VariableAddress[d] : +# 190| r190_5(unsigned int &) = Load : &:r190_4, m184_20 +# 190| r190_6(unsigned int) = Load : &:r190_5, ~m184_23 +# 186| m186_1(unknown) = InlineAsm : ~m184_23, 0:r189_3, 1:r189_6, 2:r190_3, 3:r190_6 +# 186| m186_2(unknown) = Chi : total:m184_23, partial:m186_1 +# 192| v192_1(void) = NoOp : +# 184| v184_24(void) = ReturnIndirection : &:r184_6, ~m186_2 +# 184| v184_25(void) = ReturnIndirection : &:r184_11, ~m186_2 +# 184| v184_26(void) = ReturnIndirection : &:r184_16, ~m186_2 +# 184| v184_27(void) = ReturnIndirection : &:r184_21, ~m186_2 +# 184| v184_28(void) = ReturnVoid : +# 184| v184_29(void) = UnmodeledUse : mu* +# 184| v184_30(void) = AliasedUse : ~m186_2 +# 184| v184_31(void) = ExitFunction : + +# 198| int PureFunctions(char*, char*, int) +# 198| Block 0 +# 198| v198_1(void) = EnterFunction : +# 198| m198_2(unknown) = AliasedDefinition : +# 198| mu198_3(unknown) = UnmodeledDefinition : +# 198| r198_4(glval) = VariableAddress[str1] : +# 198| m198_5(char *) = InitializeParameter[str1] : &:r198_4 +# 198| r198_6(char *) = Load : &:r198_4, m198_5 +# 198| m198_7(unknown) = InitializeIndirection[str1] : &:r198_6 +# 198| m198_8(unknown) = Chi : total:m198_2, partial:m198_7 +# 198| r198_9(glval) = VariableAddress[str2] : +# 198| m198_10(char *) = InitializeParameter[str2] : &:r198_9 +# 198| r198_11(char *) = Load : &:r198_9, m198_10 +# 198| m198_12(unknown) = InitializeIndirection[str2] : &:r198_11 +# 198| m198_13(unknown) = Chi : total:m198_8, partial:m198_12 +# 198| r198_14(glval) = VariableAddress[x] : +# 198| m198_15(int) = InitializeParameter[x] : &:r198_14 +# 199| r199_1(glval) = VariableAddress[ret] : +# 199| r199_2(glval) = FunctionAddress[strcmp] : +# 199| r199_3(glval) = VariableAddress[str1] : +# 199| r199_4(char *) = Load : &:r199_3, m198_5 +# 199| r199_5(char *) = Convert : r199_4 +# 199| r199_6(glval) = VariableAddress[str2] : +# 199| r199_7(char *) = Load : &:r199_6, m198_10 +# 199| r199_8(char *) = Convert : r199_7 +# 199| r199_9(int) = Call : func:r199_2, 0:r199_5, 1:r199_8 +# 199| v199_10(void) = ^CallReadSideEffect : ~m198_13 +# 199| m199_11(int) = Store : &:r199_1, r199_9 +# 200| r200_1(glval) = FunctionAddress[strlen] : +# 200| r200_2(glval) = VariableAddress[str1] : +# 200| r200_3(char *) = Load : &:r200_2, m198_5 +# 200| r200_4(char *) = Convert : r200_3 +# 200| r200_5(int) = Call : func:r200_1, 0:r200_4 +# 200| v200_6(void) = ^CallReadSideEffect : ~m198_13 +# 200| r200_7(glval) = VariableAddress[ret] : +# 200| r200_8(int) = Load : &:r200_7, m199_11 +# 200| r200_9(int) = Add : r200_8, r200_5 +# 200| m200_10(int) = Store : &:r200_7, r200_9 +# 201| r201_1(glval) = FunctionAddress[abs] : +# 201| r201_2(glval) = VariableAddress[x] : +# 201| r201_3(int) = Load : &:r201_2, m198_15 +# 201| r201_4(int) = Call : func:r201_1, 0:r201_3 +# 201| r201_5(glval) = VariableAddress[ret] : +# 201| r201_6(int) = Load : &:r201_5, m200_10 +# 201| r201_7(int) = Add : r201_6, r201_4 +# 201| m201_8(int) = Store : &:r201_5, r201_7 +# 202| r202_1(glval) = VariableAddress[#return] : +# 202| r202_2(glval) = VariableAddress[ret] : +# 202| r202_3(int) = Load : &:r202_2, m201_8 +# 202| m202_4(int) = Store : &:r202_1, r202_3 +# 198| v198_16(void) = ReturnIndirection : &:r198_6, ~m198_13 +# 198| v198_17(void) = ReturnIndirection : &:r198_11, ~m198_13 +# 198| r198_18(glval) = VariableAddress[#return] : +# 198| v198_19(void) = ReturnValue : &:r198_18, m202_4 +# 198| v198_20(void) = UnmodeledUse : mu* +# 198| v198_21(void) = AliasedUse : ~m198_13 +# 198| v198_22(void) = ExitFunction : + +# 207| int ModeledCallTarget(int) +# 207| Block 0 +# 207| v207_1(void) = EnterFunction : +# 207| m207_2(unknown) = AliasedDefinition : +# 207| mu207_3(unknown) = UnmodeledDefinition : +# 207| r207_4(glval) = VariableAddress[x] : +# 207| m207_5(int) = InitializeParameter[x] : &:r207_4 +# 208| r208_1(glval) = VariableAddress[y] : +# 208| m208_2(int) = Uninitialized[y] : &:r208_1 +# 209| r209_1(glval) = FunctionAddress[memcpy] : +# 209| r209_2(glval) = VariableAddress[y] : +# 209| r209_3(int *) = CopyValue : r209_2 +# 209| r209_4(void *) = Convert : r209_3 +# 209| r209_5(glval) = VariableAddress[x] : +# 209| r209_6(int *) = CopyValue : r209_5 +# 209| r209_7(void *) = Convert : r209_6 +# 209| r209_8(int) = Constant[4] : +# 209| r209_9(void *) = Call : func:r209_1, 0:r209_4, 1:r209_7, 2:r209_8 +# 209| v209_10(void) = ^SizedBufferReadSideEffect[1] : &:r209_7, r209_8, ~m207_5 +# 209| m209_11(unknown) = ^SizedBufferMustWriteSideEffect[0] : &:r209_4, r209_8 +# 209| m209_12(int) = Chi : total:m208_2, partial:m209_11 +# 210| r210_1(glval) = VariableAddress[#return] : +# 210| r210_2(glval) = VariableAddress[y] : +# 210| r210_3(int) = Load : &:r210_2, ~m209_12 +# 210| m210_4(int) = Store : &:r210_1, r210_3 +# 207| r207_6(glval) = VariableAddress[#return] : +# 207| v207_7(void) = ReturnValue : &:r207_6, m210_4 +# 207| v207_8(void) = UnmodeledUse : mu* +# 207| v207_9(void) = AliasedUse : ~m207_2 +# 207| v207_10(void) = ExitFunction : + +# 213| void InitArray() +# 213| Block 0 +# 213| v213_1(void) = EnterFunction : +# 213| m213_2(unknown) = AliasedDefinition : +# 213| mu213_3(unknown) = UnmodeledDefinition : +# 214| r214_1(glval) = VariableAddress[a_pad] : +# 214| r214_2(glval) = StringConstant[""] : +# 214| r214_3(char[32]) = Load : &:r214_2, ~m213_2 +# 214| m214_4(char[32]) = Store : &:r214_1, r214_3 +# 215| r215_1(glval) = VariableAddress[a_nopad] : +# 215| r215_2(glval) = StringConstant["foo"] : +# 215| r215_3(char[4]) = Load : &:r215_2, ~m213_2 +# 215| m215_4(char[4]) = Store : &:r215_1, r215_3 +# 216| r216_1(glval) = VariableAddress[a_infer] : +# 216| r216_2(glval) = StringConstant["blah"] : +# 216| r216_3(char[5]) = Load : &:r216_2, ~m213_2 +# 216| m216_4(char[5]) = Store : &:r216_1, r216_3 +# 217| r217_1(glval) = VariableAddress[b] : +# 217| m217_2(char[2]) = Uninitialized[b] : &:r217_1 +# 218| r218_1(glval) = VariableAddress[c] : +# 218| m218_2(char[2]) = Uninitialized[c] : &:r218_1 +# 218| r218_3(int) = Constant[0] : +# 218| r218_4(glval) = PointerAdd[1] : r218_1, r218_3 +# 218| r218_5(unknown[2]) = Constant[0] : +# 218| m218_6(unknown[2]) = Store : &:r218_4, r218_5 +# 219| r219_1(glval) = VariableAddress[d] : +# 219| m219_2(char[2]) = Uninitialized[d] : &:r219_1 +# 219| r219_3(int) = Constant[0] : +# 219| r219_4(glval) = PointerAdd[1] : r219_1, r219_3 +# 219| r219_5(char) = Constant[0] : +# 219| m219_6(char) = Store : &:r219_4, r219_5 +# 219| m219_7(char[2]) = Chi : total:m219_2, partial:m219_6 +# 219| r219_8(int) = Constant[1] : +# 219| r219_9(glval) = PointerAdd[1] : r219_1, r219_8 +# 219| r219_10(char) = Constant[0] : +# 219| m219_11(char) = Store : &:r219_9, r219_10 +# 219| m219_12(char[2]) = Chi : total:m219_7, partial:m219_11 +# 220| r220_1(glval) = VariableAddress[e] : +# 220| m220_2(char[2]) = Uninitialized[e] : &:r220_1 +# 220| r220_3(int) = Constant[0] : +# 220| r220_4(glval) = PointerAdd[1] : r220_1, r220_3 +# 220| r220_5(char) = Constant[0] : +# 220| m220_6(char) = Store : &:r220_4, r220_5 +# 220| m220_7(char[2]) = Chi : total:m220_2, partial:m220_6 +# 220| r220_8(int) = Constant[1] : +# 220| r220_9(glval) = PointerAdd[1] : r220_1, r220_8 +# 220| r220_10(char) = Constant[1] : +# 220| m220_11(char) = Store : &:r220_9, r220_10 +# 220| m220_12(char[2]) = Chi : total:m220_7, partial:m220_11 +# 221| r221_1(glval) = VariableAddress[f] : +# 221| m221_2(char[3]) = Uninitialized[f] : &:r221_1 +# 221| r221_3(int) = Constant[0] : +# 221| r221_4(glval) = PointerAdd[1] : r221_1, r221_3 +# 221| r221_5(char) = Constant[0] : +# 221| m221_6(char) = Store : &:r221_4, r221_5 +# 221| m221_7(char[3]) = Chi : total:m221_2, partial:m221_6 +# 221| r221_8(int) = Constant[1] : +# 221| r221_9(glval) = PointerAdd[1] : r221_1, r221_8 +# 221| r221_10(unknown[2]) = Constant[0] : +# 221| m221_11(unknown[2]) = Store : &:r221_9, r221_10 +# 221| m221_12(char[3]) = Chi : total:m221_7, partial:m221_11 +# 222| v222_1(void) = NoOp : +# 213| v213_4(void) = ReturnVoid : +# 213| v213_5(void) = UnmodeledUse : mu* +# 213| v213_6(void) = AliasedUse : ~m213_2 +# 213| v213_7(void) = ExitFunction : + +# 226| char StringLiteralAliasing() +# 226| Block 0 +# 226| v226_1(void) = EnterFunction : +# 226| m226_2(unknown) = AliasedDefinition : +# 226| mu226_3(unknown) = UnmodeledDefinition : +# 227| r227_1(glval) = FunctionAddress[ExternalFunc] : +# 227| v227_2(void) = Call : func:r227_1 +# 227| m227_3(unknown) = ^CallSideEffect : ~m226_2 +# 227| m227_4(unknown) = Chi : total:m226_2, partial:m227_3 +# 229| r229_1(glval) = VariableAddress[s] : +# 229| r229_2(glval) = StringConstant["Literal"] : +# 229| r229_3(char *) = Convert : r229_2 +# 229| m229_4(char *) = Store : &:r229_1, r229_3 +# 230| r230_1(glval) = VariableAddress[#return] : +# 230| r230_2(glval) = VariableAddress[s] : +# 230| r230_3(char *) = Load : &:r230_2, m229_4 +# 230| r230_4(int) = Constant[2] : +# 230| r230_5(glval) = PointerAdd[1] : r230_3, r230_4 +# 230| r230_6(char) = Load : &:r230_5, ~m226_2 +# 230| m230_7(char) = Store : &:r230_1, r230_6 +# 226| r226_4(glval) = VariableAddress[#return] : +# 226| v226_5(void) = ReturnValue : &:r226_4, m230_7 +# 226| v226_6(void) = UnmodeledUse : mu* +# 226| v226_7(void) = AliasedUse : ~m227_4 +# 226| v226_8(void) = ExitFunction : + +# 235| void Constructible::Constructible(int) +# 235| Block 0 +# 235| v235_1(void) = EnterFunction : +# 235| m235_2(unknown) = AliasedDefinition : +# 235| mu235_3(unknown) = UnmodeledDefinition : +# 235| r235_4(glval) = InitializeThis : +# 235| r235_5(glval) = VariableAddress[x] : +# 235| m235_6(int) = InitializeParameter[x] : &:r235_5 +# 235| v235_7(void) = NoOp : +# 235| v235_8(void) = ReturnVoid : +# 235| v235_9(void) = UnmodeledUse : mu* +# 235| v235_10(void) = AliasedUse : ~m235_2 +# 235| v235_11(void) = ExitFunction : + +# 236| void Constructible::g() +# 236| Block 0 +# 236| v236_1(void) = EnterFunction : +# 236| m236_2(unknown) = AliasedDefinition : +# 236| mu236_3(unknown) = UnmodeledDefinition : +# 236| r236_4(glval) = InitializeThis : +# 236| v236_5(void) = NoOp : +# 236| v236_6(void) = ReturnVoid : +# 236| v236_7(void) = UnmodeledUse : mu* +# 236| v236_8(void) = AliasedUse : ~m236_2 +# 236| v236_9(void) = ExitFunction : + +# 239| void ExplicitConstructorCalls() +# 239| Block 0 +# 239| v239_1(void) = EnterFunction : +# 239| m239_2(unknown) = AliasedDefinition : +# 239| mu239_3(unknown) = UnmodeledDefinition : +# 240| r240_1(glval) = VariableAddress[c] : +# 240| m240_2(Constructible) = Uninitialized[c] : &:r240_1 +# 240| r240_3(glval) = FunctionAddress[Constructible] : +# 240| r240_4(int) = Constant[1] : +# 240| v240_5(void) = Call : func:r240_3, this:r240_1, 0:r240_4 +# 240| m240_6(unknown) = ^CallSideEffect : ~m239_2 +# 240| m240_7(unknown) = Chi : total:m239_2, partial:m240_6 +# 240| m240_8(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r240_1 +# 240| m240_9(Constructible) = Chi : total:m240_2, partial:m240_8 +# 241| r241_1(glval) = VariableAddress[c] : +# 241| r241_2(glval) = FunctionAddress[g] : +# 241| v241_3(void) = Call : func:r241_2, this:r241_1 +# 241| m241_4(unknown) = ^CallSideEffect : ~m240_7 +# 241| m241_5(unknown) = Chi : total:m240_7, partial:m241_4 +# 241| v241_6(void) = ^BufferReadSideEffect[-1] : &:r241_1, ~m240_9 +# 241| m241_7(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r241_1 +# 241| m241_8(Constructible) = Chi : total:m240_9, partial:m241_7 +# 242| r242_1(glval) = VariableAddress[c] : +# 242| r242_2(glval) = FunctionAddress[g] : +# 242| v242_3(void) = Call : func:r242_2, this:r242_1 +# 242| m242_4(unknown) = ^CallSideEffect : ~m241_5 +# 242| m242_5(unknown) = Chi : total:m241_5, partial:m242_4 +# 242| v242_6(void) = ^BufferReadSideEffect[-1] : &:r242_1, ~m241_8 +# 242| m242_7(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r242_1 +# 242| m242_8(Constructible) = Chi : total:m241_8, partial:m242_7 +# 243| r243_1(glval) = VariableAddress[c2] : +# 243| m243_2(Constructible) = Uninitialized[c2] : &:r243_1 +# 243| r243_3(glval) = FunctionAddress[Constructible] : +# 243| r243_4(int) = Constant[2] : +# 243| v243_5(void) = Call : func:r243_3, this:r243_1, 0:r243_4 +# 243| m243_6(unknown) = ^CallSideEffect : ~m242_5 +# 243| m243_7(unknown) = Chi : total:m242_5, partial:m243_6 +# 243| m243_8(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r243_1 +# 243| m243_9(Constructible) = Chi : total:m243_2, partial:m243_8 +# 244| r244_1(glval) = VariableAddress[c2] : +# 244| r244_2(glval) = FunctionAddress[g] : +# 244| v244_3(void) = Call : func:r244_2, this:r244_1 +# 244| m244_4(unknown) = ^CallSideEffect : ~m243_7 +# 244| m244_5(unknown) = Chi : total:m243_7, partial:m244_4 +# 244| v244_6(void) = ^BufferReadSideEffect[-1] : &:r244_1, ~m243_9 +# 244| m244_7(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r244_1 +# 244| m244_8(Constructible) = Chi : total:m243_9, partial:m244_7 +# 245| v245_1(void) = NoOp : +# 239| v239_4(void) = ReturnVoid : +# 239| v239_5(void) = UnmodeledUse : mu* +# 239| v239_6(void) = AliasedUse : ~m244_5 +# 239| v239_7(void) = ExitFunction : diff --git a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir.qlref b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir_unsound.qlref similarity index 100% rename from cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir.qlref rename to cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir_unsound.qlref diff --git a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_sanity.ql b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_sanity.ql new file mode 100644 index 00000000000..74fa11944a6 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_sanity.ql @@ -0,0 +1,2 @@ +import semmle.code.cpp.ir.implementation.aliased_ssa.IRSanity +import semmle.code.cpp.ir.implementation.UseSoundEscapeAnalysis diff --git a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_sanity_unsound.expected b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_sanity_unsound.expected new file mode 100644 index 00000000000..9769ee11f99 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_sanity_unsound.expected @@ -0,0 +1,22 @@ +missingOperand +unexpectedOperand +duplicateOperand +missingPhiOperand +missingOperandType +duplicateChiOperand +sideEffectWithoutPrimary +instructionWithoutSuccessor +ambiguousSuccessors +unexplainedLoop +unnecessaryPhiInstruction +operandAcrossFunctions +instructionWithoutUniqueBlock +containsLoopOfForwardEdges +lostReachability +backEdgeCountMismatch +useNotDominatedByDefinition +missingCanonicalLanguageType +multipleCanonicalLanguageTypes +missingIRType +multipleIRTypes +missingCppType diff --git a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_sanity.qlref b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_sanity_unsound.qlref similarity index 100% rename from cpp/ql/test/library-tests/ir/ssa/aliased_ssa_sanity.qlref rename to cpp/ql/test/library-tests/ir/ssa/aliased_ssa_sanity_unsound.qlref diff --git a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ssa_sanity.ql b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ssa_sanity.ql new file mode 100644 index 00000000000..b3962e34648 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ssa_sanity.ql @@ -0,0 +1,2 @@ +import semmle.code.cpp.ir.implementation.aliased_ssa.internal.SSASanity +import semmle.code.cpp.ir.implementation.UseSoundEscapeAnalysis diff --git a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ssa_sanity_unsound.expected b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ssa_sanity_unsound.expected new file mode 100644 index 00000000000..7c2d1faf639 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ssa_sanity_unsound.expected @@ -0,0 +1,2 @@ +multipleOperandMemoryLocations +missingVirtualVariableForMemoryLocation diff --git a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ssa_sanity.qlref b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ssa_sanity_unsound.qlref similarity index 100% rename from cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ssa_sanity.qlref rename to cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ssa_sanity_unsound.qlref diff --git a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir.ql b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir.ql new file mode 100644 index 00000000000..100f2815a58 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir.ql @@ -0,0 +1,6 @@ +/** + * @kind graph + */ + +import semmle.code.cpp.ir.implementation.unaliased_ssa.PrintIR +import semmle.code.cpp.ir.implementation.UseSoundEscapeAnalysis diff --git a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir_unsound.expected b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir_unsound.expected new file mode 100644 index 00000000000..5ea397b91dc --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir_unsound.expected @@ -0,0 +1,1025 @@ +ssa.cpp: +# 13| int ChiPhiNode(Point*, bool, bool) +# 13| Block 0 +# 13| v13_1(void) = EnterFunction : +# 13| mu13_2(unknown) = AliasedDefinition : +# 13| mu13_3(unknown) = UnmodeledDefinition : +# 13| r13_4(glval) = VariableAddress[p] : +# 13| m13_5(Point *) = InitializeParameter[p] : &:r13_4 +# 13| r13_6(Point *) = Load : &:r13_4, m13_5 +# 13| mu13_7(unknown) = InitializeIndirection[p] : &:r13_6 +# 13| r13_8(glval) = VariableAddress[which1] : +# 13| m13_9(bool) = InitializeParameter[which1] : &:r13_8 +# 13| r13_10(glval) = VariableAddress[which2] : +# 13| m13_11(bool) = InitializeParameter[which2] : &:r13_10 +# 14| r14_1(glval) = VariableAddress[which1] : +# 14| r14_2(bool) = Load : &:r14_1, m13_9 +# 14| v14_3(void) = ConditionalBranch : r14_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 15| Block 1 +# 15| r15_1(glval) = VariableAddress[p] : +# 15| r15_2(Point *) = Load : &:r15_1, m13_5 +# 15| r15_3(glval) = FieldAddress[x] : r15_2 +# 15| r15_4(int) = Load : &:r15_3, ~mu13_3 +# 15| r15_5(int) = Constant[1] : +# 15| r15_6(int) = Add : r15_4, r15_5 +# 15| mu15_7(int) = Store : &:r15_3, r15_6 +#-----| Goto -> Block 3 + +# 18| Block 2 +# 18| r18_1(glval) = VariableAddress[p] : +# 18| r18_2(Point *) = Load : &:r18_1, m13_5 +# 18| r18_3(glval) = FieldAddress[y] : r18_2 +# 18| r18_4(int) = Load : &:r18_3, ~mu13_3 +# 18| r18_5(int) = Constant[1] : +# 18| r18_6(int) = Add : r18_4, r18_5 +# 18| mu18_7(int) = Store : &:r18_3, r18_6 +#-----| Goto -> Block 3 + +# 21| Block 3 +# 21| r21_1(glval) = VariableAddress[which2] : +# 21| r21_2(bool) = Load : &:r21_1, m13_11 +# 21| v21_3(void) = ConditionalBranch : r21_2 +#-----| False -> Block 5 +#-----| True -> Block 4 + +# 22| Block 4 +# 22| r22_1(glval) = VariableAddress[p] : +# 22| r22_2(Point *) = Load : &:r22_1, m13_5 +# 22| r22_3(glval) = FieldAddress[x] : r22_2 +# 22| r22_4(int) = Load : &:r22_3, ~mu13_3 +# 22| r22_5(int) = Constant[1] : +# 22| r22_6(int) = Add : r22_4, r22_5 +# 22| mu22_7(int) = Store : &:r22_3, r22_6 +#-----| Goto -> Block 6 + +# 25| Block 5 +# 25| r25_1(glval) = VariableAddress[p] : +# 25| r25_2(Point *) = Load : &:r25_1, m13_5 +# 25| r25_3(glval) = FieldAddress[y] : r25_2 +# 25| r25_4(int) = Load : &:r25_3, ~mu13_3 +# 25| r25_5(int) = Constant[1] : +# 25| r25_6(int) = Add : r25_4, r25_5 +# 25| mu25_7(int) = Store : &:r25_3, r25_6 +#-----| Goto -> Block 6 + +# 28| Block 6 +# 28| r28_1(glval) = VariableAddress[#return] : +# 28| r28_2(glval) = VariableAddress[p] : +# 28| r28_3(Point *) = Load : &:r28_2, m13_5 +# 28| r28_4(glval) = FieldAddress[x] : r28_3 +# 28| r28_5(int) = Load : &:r28_4, ~mu13_3 +# 28| r28_6(glval) = VariableAddress[p] : +# 28| r28_7(Point *) = Load : &:r28_6, m13_5 +# 28| r28_8(glval) = FieldAddress[y] : r28_7 +# 28| r28_9(int) = Load : &:r28_8, ~mu13_3 +# 28| r28_10(int) = Add : r28_5, r28_9 +# 28| m28_11(int) = Store : &:r28_1, r28_10 +# 13| v13_12(void) = ReturnIndirection : &:r13_6, ~mu13_3 +# 13| r13_13(glval) = VariableAddress[#return] : +# 13| v13_14(void) = ReturnValue : &:r13_13, m28_11 +# 13| v13_15(void) = UnmodeledUse : mu* +# 13| v13_16(void) = AliasedUse : ~mu13_3 +# 13| v13_17(void) = ExitFunction : + +# 31| int UnreachableViaGoto() +# 31| Block 0 +# 31| v31_1(void) = EnterFunction : +# 31| mu31_2(unknown) = AliasedDefinition : +# 31| mu31_3(unknown) = UnmodeledDefinition : +# 32| v32_1(void) = NoOp : +# 34| v34_1(void) = NoOp : +# 35| r35_1(glval) = VariableAddress[#return] : +# 35| r35_2(int) = Constant[0] : +# 35| m35_3(int) = Store : &:r35_1, r35_2 +# 31| r31_4(glval) = VariableAddress[#return] : +# 31| v31_5(void) = ReturnValue : &:r31_4, m35_3 +# 31| v31_6(void) = UnmodeledUse : mu* +# 31| v31_7(void) = AliasedUse : ~mu31_3 +# 31| v31_8(void) = ExitFunction : + +# 38| int UnreachableIf(bool) +# 38| Block 0 +# 38| v38_1(void) = EnterFunction : +# 38| mu38_2(unknown) = AliasedDefinition : +# 38| mu38_3(unknown) = UnmodeledDefinition : +# 38| r38_4(glval) = VariableAddress[b] : +# 38| m38_5(bool) = InitializeParameter[b] : &:r38_4 +# 39| r39_1(glval) = VariableAddress[x] : +# 39| r39_2(int) = Constant[5] : +# 39| m39_3(int) = Store : &:r39_1, r39_2 +# 40| r40_1(glval) = VariableAddress[y] : +# 40| r40_2(int) = Constant[10] : +# 40| m40_3(int) = Store : &:r40_1, r40_2 +# 41| r41_1(glval) = VariableAddress[b] : +# 41| r41_2(bool) = Load : &:r41_1, m38_5 +# 41| v41_3(void) = ConditionalBranch : r41_2 +#-----| False -> Block 5 +#-----| True -> Block 2 + +# 38| Block 1 +# 38| m38_6(int) = Phi : from 3:m43_3, from 4:m46_3, from 6:m51_3, from 7:m54_3 +# 38| r38_7(glval) = VariableAddress[#return] : +# 38| v38_8(void) = ReturnValue : &:r38_7, m38_6 +# 38| v38_9(void) = UnmodeledUse : mu* +# 38| v38_10(void) = AliasedUse : ~mu38_3 +# 38| v38_11(void) = ExitFunction : + +# 42| Block 2 +# 42| r42_1(glval) = VariableAddress[x] : +# 42| r42_2(int) = Load : &:r42_1, m39_3 +# 42| r42_3(glval) = VariableAddress[y] : +# 42| r42_4(int) = Load : &:r42_3, m40_3 +# 42| r42_5(bool) = CompareEQ : r42_2, r42_4 +# 42| v42_6(void) = ConditionalBranch : r42_5 +#-----| False -> Block 4 +#-----| True -> Block 3 + +# 43| Block 3 +# 43| r43_1(glval) = VariableAddress[#return] : +# 43| r43_2(int) = Constant[1] : +# 43| m43_3(int) = Store : &:r43_1, r43_2 +#-----| Goto -> Block 1 + +# 46| Block 4 +# 46| r46_1(glval) = VariableAddress[#return] : +# 46| r46_2(int) = Constant[0] : +# 46| m46_3(int) = Store : &:r46_1, r46_2 +#-----| Goto -> Block 1 + +# 50| Block 5 +# 50| r50_1(glval) = VariableAddress[x] : +# 50| r50_2(int) = Load : &:r50_1, m39_3 +# 50| r50_3(glval) = VariableAddress[y] : +# 50| r50_4(int) = Load : &:r50_3, m40_3 +# 50| r50_5(bool) = CompareLT : r50_2, r50_4 +# 50| v50_6(void) = ConditionalBranch : r50_5 +#-----| False -> Block 7 +#-----| True -> Block 6 + +# 51| Block 6 +# 51| r51_1(glval) = VariableAddress[#return] : +# 51| r51_2(int) = Constant[0] : +# 51| m51_3(int) = Store : &:r51_1, r51_2 +#-----| Goto -> Block 1 + +# 54| Block 7 +# 54| r54_1(glval) = VariableAddress[#return] : +# 54| r54_2(int) = Constant[1] : +# 54| m54_3(int) = Store : &:r54_1, r54_2 +#-----| Goto -> Block 1 + +# 59| int DoWhileFalse() +# 59| Block 0 +# 59| v59_1(void) = EnterFunction : +# 59| mu59_2(unknown) = AliasedDefinition : +# 59| mu59_3(unknown) = UnmodeledDefinition : +# 60| r60_1(glval) = VariableAddress[i] : +# 60| r60_2(int) = Constant[0] : +# 60| m60_3(int) = Store : &:r60_1, r60_2 +# 62| r62_1(glval) = VariableAddress[i] : +# 62| r62_2(int) = Load : &:r62_1, m60_3 +# 62| r62_3(int) = Constant[1] : +# 62| r62_4(int) = Add : r62_2, r62_3 +# 62| m62_5(int) = Store : &:r62_1, r62_4 +# 63| r63_1(bool) = Constant[0] : +# 63| v63_2(void) = ConditionalBranch : r63_1 +#-----| False -> Block 1 +#-----| True -> Block 2 + +# 65| Block 1 +# 65| r65_1(glval) = VariableAddress[#return] : +# 65| r65_2(glval) = VariableAddress[i] : +# 65| r65_3(int) = Load : &:r65_2, m62_5 +# 65| m65_4(int) = Store : &:r65_1, r65_3 +# 59| r59_4(glval) = VariableAddress[#return] : +# 59| v59_5(void) = ReturnValue : &:r59_4, m65_4 +# 59| v59_6(void) = UnmodeledUse : mu* +# 59| v59_7(void) = AliasedUse : ~mu59_3 +# 59| v59_8(void) = ExitFunction : + +# 59| Block 2 +# 59| v59_9(void) = Unreached : + +# 68| void chiNodeAtEndOfLoop(int, char*) +# 68| Block 0 +# 68| v68_1(void) = EnterFunction : +# 68| mu68_2(unknown) = AliasedDefinition : +# 68| mu68_3(unknown) = UnmodeledDefinition : +# 68| r68_4(glval) = VariableAddress[n] : +# 68| m68_5(int) = InitializeParameter[n] : &:r68_4 +# 68| r68_6(glval) = VariableAddress[p] : +# 68| m68_7(char *) = InitializeParameter[p] : &:r68_6 +# 68| r68_8(char *) = Load : &:r68_6, m68_7 +# 68| mu68_9(unknown) = InitializeIndirection[p] : &:r68_8 +#-----| Goto -> Block 3 + +# 70| Block 1 +# 70| r70_1(char) = Constant[0] : +# 70| r70_2(glval) = VariableAddress[p] : +# 70| r70_3(char *) = Load : &:r70_2, m69_1 +# 70| r70_4(int) = Constant[1] : +# 70| r70_5(char *) = PointerAdd[1] : r70_3, r70_4 +# 70| m70_6(char *) = Store : &:r70_2, r70_5 +# 70| r70_7(glval) = CopyValue : r70_3 +# 70| mu70_8(char) = Store : &:r70_7, r70_1 +#-----| Goto (back edge) -> Block 3 + +# 71| Block 2 +# 71| v71_1(void) = NoOp : +# 68| v68_10(void) = ReturnIndirection : &:r68_8, ~mu68_3 +# 68| v68_11(void) = ReturnVoid : +# 68| v68_12(void) = UnmodeledUse : mu* +# 68| v68_13(void) = AliasedUse : ~mu68_3 +# 68| v68_14(void) = ExitFunction : + +# 69| Block 3 +# 69| m69_1(char *) = Phi : from 0:m68_7, from 1:m70_6 +# 69| m69_2(int) = Phi : from 0:m68_5, from 1:m69_7 +# 69| r69_3(glval) = VariableAddress[n] : +# 69| r69_4(int) = Load : &:r69_3, m69_2 +# 69| r69_5(int) = Constant[1] : +# 69| r69_6(int) = Sub : r69_4, r69_5 +# 69| m69_7(int) = Store : &:r69_3, r69_6 +# 69| r69_8(int) = Constant[0] : +# 69| r69_9(bool) = CompareGT : r69_4, r69_8 +# 69| v69_10(void) = ConditionalBranch : r69_9 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 75| void ScalarPhi(bool) +# 75| Block 0 +# 75| v75_1(void) = EnterFunction : +# 75| mu75_2(unknown) = AliasedDefinition : +# 75| mu75_3(unknown) = UnmodeledDefinition : +# 75| r75_4(glval) = VariableAddress[b] : +# 75| m75_5(bool) = InitializeParameter[b] : &:r75_4 +# 76| r76_1(glval) = VariableAddress[x] : +# 76| r76_2(int) = Constant[0] : +# 76| m76_3(int) = Store : &:r76_1, r76_2 +# 77| r77_1(glval) = VariableAddress[y] : +# 77| r77_2(int) = Constant[1] : +# 77| m77_3(int) = Store : &:r77_1, r77_2 +# 78| r78_1(glval) = VariableAddress[z] : +# 78| r78_2(int) = Constant[2] : +# 78| m78_3(int) = Store : &:r78_1, r78_2 +# 79| r79_1(glval) = VariableAddress[b] : +# 79| r79_2(bool) = Load : &:r79_1, m75_5 +# 79| v79_3(void) = ConditionalBranch : r79_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 80| Block 1 +# 80| r80_1(int) = Constant[3] : +# 80| r80_2(glval) = VariableAddress[x] : +# 80| m80_3(int) = Store : &:r80_2, r80_1 +# 81| r81_1(int) = Constant[4] : +# 81| r81_2(glval) = VariableAddress[y] : +# 81| m81_3(int) = Store : &:r81_2, r81_1 +#-----| Goto -> Block 3 + +# 84| Block 2 +# 84| r84_1(int) = Constant[5] : +# 84| r84_2(glval) = VariableAddress[x] : +# 84| m84_3(int) = Store : &:r84_2, r84_1 +#-----| Goto -> Block 3 + +# 86| Block 3 +# 86| m86_1(int) = Phi : from 1:m81_3, from 2:m77_3 +# 86| m86_2(int) = Phi : from 1:m80_3, from 2:m84_3 +# 86| r86_3(glval) = VariableAddress[x_merge] : +# 86| r86_4(glval) = VariableAddress[x] : +# 86| r86_5(int) = Load : &:r86_4, m86_2 +# 86| m86_6(int) = Store : &:r86_3, r86_5 +# 87| r87_1(glval) = VariableAddress[y_merge] : +# 87| r87_2(glval) = VariableAddress[y] : +# 87| r87_3(int) = Load : &:r87_2, m86_1 +# 87| m87_4(int) = Store : &:r87_1, r87_3 +# 88| r88_1(glval) = VariableAddress[z_merge] : +# 88| r88_2(glval) = VariableAddress[z] : +# 88| r88_3(int) = Load : &:r88_2, m78_3 +# 88| m88_4(int) = Store : &:r88_1, r88_3 +# 89| v89_1(void) = NoOp : +# 75| v75_6(void) = ReturnVoid : +# 75| v75_7(void) = UnmodeledUse : mu* +# 75| v75_8(void) = AliasedUse : ~mu75_3 +# 75| v75_9(void) = ExitFunction : + +# 91| void MustExactlyOverlap(Point) +# 91| Block 0 +# 91| v91_1(void) = EnterFunction : +# 91| mu91_2(unknown) = AliasedDefinition : +# 91| mu91_3(unknown) = UnmodeledDefinition : +# 91| r91_4(glval) = VariableAddress[a] : +# 91| m91_5(Point) = InitializeParameter[a] : &:r91_4 +# 92| r92_1(glval) = VariableAddress[b] : +# 92| r92_2(glval) = VariableAddress[a] : +# 92| r92_3(Point) = Load : &:r92_2, m91_5 +# 92| m92_4(Point) = Store : &:r92_1, r92_3 +# 93| v93_1(void) = NoOp : +# 91| v91_6(void) = ReturnVoid : +# 91| v91_7(void) = UnmodeledUse : mu* +# 91| v91_8(void) = AliasedUse : ~mu91_3 +# 91| v91_9(void) = ExitFunction : + +# 95| void MustExactlyOverlapEscaped(Point) +# 95| Block 0 +# 95| v95_1(void) = EnterFunction : +# 95| mu95_2(unknown) = AliasedDefinition : +# 95| mu95_3(unknown) = UnmodeledDefinition : +# 95| r95_4(glval) = VariableAddress[a] : +# 95| mu95_5(Point) = InitializeParameter[a] : &:r95_4 +# 96| r96_1(glval) = VariableAddress[b] : +# 96| r96_2(glval) = VariableAddress[a] : +# 96| r96_3(Point) = Load : &:r96_2, ~mu95_3 +# 96| m96_4(Point) = Store : &:r96_1, r96_3 +# 97| r97_1(glval) = FunctionAddress[Escape] : +# 97| r97_2(glval) = VariableAddress[a] : +# 97| r97_3(Point *) = CopyValue : r97_2 +# 97| r97_4(void *) = Convert : r97_3 +# 97| v97_5(void) = Call : func:r97_1, 0:r97_4 +# 97| mu97_6(unknown) = ^CallSideEffect : ~mu95_3 +# 97| v97_7(void) = ^BufferReadSideEffect[0] : &:r97_4, ~mu95_3 +# 97| mu97_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r97_4 +# 98| v98_1(void) = NoOp : +# 95| v95_6(void) = ReturnVoid : +# 95| v95_7(void) = UnmodeledUse : mu* +# 95| v95_8(void) = AliasedUse : ~mu95_3 +# 95| v95_9(void) = ExitFunction : + +# 100| void MustTotallyOverlap(Point) +# 100| Block 0 +# 100| v100_1(void) = EnterFunction : +# 100| mu100_2(unknown) = AliasedDefinition : +# 100| mu100_3(unknown) = UnmodeledDefinition : +# 100| r100_4(glval) = VariableAddress[a] : +# 100| mu100_5(Point) = InitializeParameter[a] : &:r100_4 +# 101| r101_1(glval) = VariableAddress[x] : +# 101| r101_2(glval) = VariableAddress[a] : +# 101| r101_3(glval) = FieldAddress[x] : r101_2 +# 101| r101_4(int) = Load : &:r101_3, ~mu100_3 +# 101| m101_5(int) = Store : &:r101_1, r101_4 +# 102| r102_1(glval) = VariableAddress[y] : +# 102| r102_2(glval) = VariableAddress[a] : +# 102| r102_3(glval) = FieldAddress[y] : r102_2 +# 102| r102_4(int) = Load : &:r102_3, ~mu100_3 +# 102| m102_5(int) = Store : &:r102_1, r102_4 +# 103| v103_1(void) = NoOp : +# 100| v100_6(void) = ReturnVoid : +# 100| v100_7(void) = UnmodeledUse : mu* +# 100| v100_8(void) = AliasedUse : ~mu100_3 +# 100| v100_9(void) = ExitFunction : + +# 105| void MustTotallyOverlapEscaped(Point) +# 105| Block 0 +# 105| v105_1(void) = EnterFunction : +# 105| mu105_2(unknown) = AliasedDefinition : +# 105| mu105_3(unknown) = UnmodeledDefinition : +# 105| r105_4(glval) = VariableAddress[a] : +# 105| mu105_5(Point) = InitializeParameter[a] : &:r105_4 +# 106| r106_1(glval) = VariableAddress[x] : +# 106| r106_2(glval) = VariableAddress[a] : +# 106| r106_3(glval) = FieldAddress[x] : r106_2 +# 106| r106_4(int) = Load : &:r106_3, ~mu105_3 +# 106| m106_5(int) = Store : &:r106_1, r106_4 +# 107| r107_1(glval) = VariableAddress[y] : +# 107| r107_2(glval) = VariableAddress[a] : +# 107| r107_3(glval) = FieldAddress[y] : r107_2 +# 107| r107_4(int) = Load : &:r107_3, ~mu105_3 +# 107| m107_5(int) = Store : &:r107_1, r107_4 +# 108| r108_1(glval) = FunctionAddress[Escape] : +# 108| r108_2(glval) = VariableAddress[a] : +# 108| r108_3(Point *) = CopyValue : r108_2 +# 108| r108_4(void *) = Convert : r108_3 +# 108| v108_5(void) = Call : func:r108_1, 0:r108_4 +# 108| mu108_6(unknown) = ^CallSideEffect : ~mu105_3 +# 108| v108_7(void) = ^BufferReadSideEffect[0] : &:r108_4, ~mu105_3 +# 108| mu108_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r108_4 +# 109| v109_1(void) = NoOp : +# 105| v105_6(void) = ReturnVoid : +# 105| v105_7(void) = UnmodeledUse : mu* +# 105| v105_8(void) = AliasedUse : ~mu105_3 +# 105| v105_9(void) = ExitFunction : + +# 111| void MayPartiallyOverlap(int, int) +# 111| Block 0 +# 111| v111_1(void) = EnterFunction : +# 111| mu111_2(unknown) = AliasedDefinition : +# 111| mu111_3(unknown) = UnmodeledDefinition : +# 111| r111_4(glval) = VariableAddress[x] : +# 111| m111_5(int) = InitializeParameter[x] : &:r111_4 +# 111| r111_6(glval) = VariableAddress[y] : +# 111| m111_7(int) = InitializeParameter[y] : &:r111_6 +# 112| r112_1(glval) = VariableAddress[a] : +# 112| mu112_2(Point) = Uninitialized[a] : &:r112_1 +# 112| r112_3(glval) = FieldAddress[x] : r112_1 +# 112| r112_4(glval) = VariableAddress[x] : +# 112| r112_5(int) = Load : &:r112_4, m111_5 +# 112| mu112_6(int) = Store : &:r112_3, r112_5 +# 112| r112_7(glval) = FieldAddress[y] : r112_1 +# 112| r112_8(glval) = VariableAddress[y] : +# 112| r112_9(int) = Load : &:r112_8, m111_7 +# 112| mu112_10(int) = Store : &:r112_7, r112_9 +# 113| r113_1(glval) = VariableAddress[b] : +# 113| r113_2(glval) = VariableAddress[a] : +# 113| r113_3(Point) = Load : &:r113_2, ~mu111_3 +# 113| m113_4(Point) = Store : &:r113_1, r113_3 +# 114| v114_1(void) = NoOp : +# 111| v111_8(void) = ReturnVoid : +# 111| v111_9(void) = UnmodeledUse : mu* +# 111| v111_10(void) = AliasedUse : ~mu111_3 +# 111| v111_11(void) = ExitFunction : + +# 116| void MayPartiallyOverlapEscaped(int, int) +# 116| Block 0 +# 116| v116_1(void) = EnterFunction : +# 116| mu116_2(unknown) = AliasedDefinition : +# 116| mu116_3(unknown) = UnmodeledDefinition : +# 116| r116_4(glval) = VariableAddress[x] : +# 116| m116_5(int) = InitializeParameter[x] : &:r116_4 +# 116| r116_6(glval) = VariableAddress[y] : +# 116| m116_7(int) = InitializeParameter[y] : &:r116_6 +# 117| r117_1(glval) = VariableAddress[a] : +# 117| mu117_2(Point) = Uninitialized[a] : &:r117_1 +# 117| r117_3(glval) = FieldAddress[x] : r117_1 +# 117| r117_4(glval) = VariableAddress[x] : +# 117| r117_5(int) = Load : &:r117_4, m116_5 +# 117| mu117_6(int) = Store : &:r117_3, r117_5 +# 117| r117_7(glval) = FieldAddress[y] : r117_1 +# 117| r117_8(glval) = VariableAddress[y] : +# 117| r117_9(int) = Load : &:r117_8, m116_7 +# 117| mu117_10(int) = Store : &:r117_7, r117_9 +# 118| r118_1(glval) = VariableAddress[b] : +# 118| r118_2(glval) = VariableAddress[a] : +# 118| r118_3(Point) = Load : &:r118_2, ~mu116_3 +# 118| m118_4(Point) = Store : &:r118_1, r118_3 +# 119| r119_1(glval) = FunctionAddress[Escape] : +# 119| r119_2(glval) = VariableAddress[a] : +# 119| r119_3(Point *) = CopyValue : r119_2 +# 119| r119_4(void *) = Convert : r119_3 +# 119| v119_5(void) = Call : func:r119_1, 0:r119_4 +# 119| mu119_6(unknown) = ^CallSideEffect : ~mu116_3 +# 119| v119_7(void) = ^BufferReadSideEffect[0] : &:r119_4, ~mu116_3 +# 119| mu119_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r119_4 +# 120| v120_1(void) = NoOp : +# 116| v116_8(void) = ReturnVoid : +# 116| v116_9(void) = UnmodeledUse : mu* +# 116| v116_10(void) = AliasedUse : ~mu116_3 +# 116| v116_11(void) = ExitFunction : + +# 122| void MergeMustExactlyOverlap(bool, int, int) +# 122| Block 0 +# 122| v122_1(void) = EnterFunction : +# 122| mu122_2(unknown) = AliasedDefinition : +# 122| mu122_3(unknown) = UnmodeledDefinition : +# 122| r122_4(glval) = VariableAddress[c] : +# 122| m122_5(bool) = InitializeParameter[c] : &:r122_4 +# 122| r122_6(glval) = VariableAddress[x1] : +# 122| m122_7(int) = InitializeParameter[x1] : &:r122_6 +# 122| r122_8(glval) = VariableAddress[x2] : +# 122| m122_9(int) = InitializeParameter[x2] : &:r122_8 +# 123| r123_1(glval) = VariableAddress[a] : +# 123| mu123_2(Point) = Uninitialized[a] : &:r123_1 +# 123| r123_3(glval) = FieldAddress[x] : r123_1 +# 123| r123_4(int) = Constant[0] : +# 123| mu123_5(int) = Store : &:r123_3, r123_4 +# 123| r123_6(glval) = FieldAddress[y] : r123_1 +# 123| r123_7(int) = Constant[0] : +# 123| mu123_8(int) = Store : &:r123_6, r123_7 +# 124| r124_1(glval) = VariableAddress[c] : +# 124| r124_2(bool) = Load : &:r124_1, m122_5 +# 124| v124_3(void) = ConditionalBranch : r124_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 125| Block 1 +# 125| r125_1(glval) = VariableAddress[x1] : +# 125| r125_2(int) = Load : &:r125_1, m122_7 +# 125| r125_3(glval) = VariableAddress[a] : +# 125| r125_4(glval) = FieldAddress[x] : r125_3 +# 125| mu125_5(int) = Store : &:r125_4, r125_2 +#-----| Goto -> Block 3 + +# 128| Block 2 +# 128| r128_1(glval) = VariableAddress[x2] : +# 128| r128_2(int) = Load : &:r128_1, m122_9 +# 128| r128_3(glval) = VariableAddress[a] : +# 128| r128_4(glval) = FieldAddress[x] : r128_3 +# 128| mu128_5(int) = Store : &:r128_4, r128_2 +#-----| Goto -> Block 3 + +# 130| Block 3 +# 130| r130_1(glval) = VariableAddress[x] : +# 130| r130_2(glval) = VariableAddress[a] : +# 130| r130_3(glval) = FieldAddress[x] : r130_2 +# 130| r130_4(int) = Load : &:r130_3, ~mu122_3 +# 130| m130_5(int) = Store : &:r130_1, r130_4 +# 131| r131_1(glval) = VariableAddress[b] : +# 131| r131_2(glval) = VariableAddress[a] : +# 131| r131_3(Point) = Load : &:r131_2, ~mu122_3 +# 131| m131_4(Point) = Store : &:r131_1, r131_3 +# 132| v132_1(void) = NoOp : +# 122| v122_10(void) = ReturnVoid : +# 122| v122_11(void) = UnmodeledUse : mu* +# 122| v122_12(void) = AliasedUse : ~mu122_3 +# 122| v122_13(void) = ExitFunction : + +# 134| void MergeMustExactlyWithMustTotallyOverlap(bool, Point, int) +# 134| Block 0 +# 134| v134_1(void) = EnterFunction : +# 134| mu134_2(unknown) = AliasedDefinition : +# 134| mu134_3(unknown) = UnmodeledDefinition : +# 134| r134_4(glval) = VariableAddress[c] : +# 134| m134_5(bool) = InitializeParameter[c] : &:r134_4 +# 134| r134_6(glval) = VariableAddress[p] : +# 134| m134_7(Point) = InitializeParameter[p] : &:r134_6 +# 134| r134_8(glval) = VariableAddress[x1] : +# 134| m134_9(int) = InitializeParameter[x1] : &:r134_8 +# 135| r135_1(glval) = VariableAddress[a] : +# 135| mu135_2(Point) = Uninitialized[a] : &:r135_1 +# 135| r135_3(glval) = FieldAddress[x] : r135_1 +# 135| r135_4(int) = Constant[0] : +# 135| mu135_5(int) = Store : &:r135_3, r135_4 +# 135| r135_6(glval) = FieldAddress[y] : r135_1 +# 135| r135_7(int) = Constant[0] : +# 135| mu135_8(int) = Store : &:r135_6, r135_7 +# 136| r136_1(glval) = VariableAddress[c] : +# 136| r136_2(bool) = Load : &:r136_1, m134_5 +# 136| v136_3(void) = ConditionalBranch : r136_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 137| Block 1 +# 137| r137_1(glval) = VariableAddress[x1] : +# 137| r137_2(int) = Load : &:r137_1, m134_9 +# 137| r137_3(glval) = VariableAddress[a] : +# 137| r137_4(glval) = FieldAddress[x] : r137_3 +# 137| mu137_5(int) = Store : &:r137_4, r137_2 +#-----| Goto -> Block 3 + +# 140| Block 2 +# 140| r140_1(glval) = VariableAddress[p] : +# 140| r140_2(Point) = Load : &:r140_1, m134_7 +# 140| r140_3(glval) = VariableAddress[a] : +# 140| mu140_4(Point) = Store : &:r140_3, r140_2 +#-----| Goto -> Block 3 + +# 142| Block 3 +# 142| r142_1(glval) = VariableAddress[x] : +# 142| r142_2(glval) = VariableAddress[a] : +# 142| r142_3(glval) = FieldAddress[x] : r142_2 +# 142| r142_4(int) = Load : &:r142_3, ~mu134_3 +# 142| m142_5(int) = Store : &:r142_1, r142_4 +# 143| v143_1(void) = NoOp : +# 134| v134_10(void) = ReturnVoid : +# 134| v134_11(void) = UnmodeledUse : mu* +# 134| v134_12(void) = AliasedUse : ~mu134_3 +# 134| v134_13(void) = ExitFunction : + +# 145| void MergeMustExactlyWithMayPartiallyOverlap(bool, Point, int) +# 145| Block 0 +# 145| v145_1(void) = EnterFunction : +# 145| mu145_2(unknown) = AliasedDefinition : +# 145| mu145_3(unknown) = UnmodeledDefinition : +# 145| r145_4(glval) = VariableAddress[c] : +# 145| m145_5(bool) = InitializeParameter[c] : &:r145_4 +# 145| r145_6(glval) = VariableAddress[p] : +# 145| m145_7(Point) = InitializeParameter[p] : &:r145_6 +# 145| r145_8(glval) = VariableAddress[x1] : +# 145| m145_9(int) = InitializeParameter[x1] : &:r145_8 +# 146| r146_1(glval) = VariableAddress[a] : +# 146| mu146_2(Point) = Uninitialized[a] : &:r146_1 +# 146| r146_3(glval) = FieldAddress[x] : r146_1 +# 146| r146_4(int) = Constant[0] : +# 146| mu146_5(int) = Store : &:r146_3, r146_4 +# 146| r146_6(glval) = FieldAddress[y] : r146_1 +# 146| r146_7(int) = Constant[0] : +# 146| mu146_8(int) = Store : &:r146_6, r146_7 +# 147| r147_1(glval) = VariableAddress[c] : +# 147| r147_2(bool) = Load : &:r147_1, m145_5 +# 147| v147_3(void) = ConditionalBranch : r147_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 148| Block 1 +# 148| r148_1(glval) = VariableAddress[x1] : +# 148| r148_2(int) = Load : &:r148_1, m145_9 +# 148| r148_3(glval) = VariableAddress[a] : +# 148| r148_4(glval) = FieldAddress[x] : r148_3 +# 148| mu148_5(int) = Store : &:r148_4, r148_2 +#-----| Goto -> Block 3 + +# 151| Block 2 +# 151| r151_1(glval) = VariableAddress[p] : +# 151| r151_2(Point) = Load : &:r151_1, m145_7 +# 151| r151_3(glval) = VariableAddress[a] : +# 151| mu151_4(Point) = Store : &:r151_3, r151_2 +#-----| Goto -> Block 3 + +# 153| Block 3 +# 153| r153_1(glval) = VariableAddress[b] : +# 153| r153_2(glval) = VariableAddress[a] : +# 153| r153_3(Point) = Load : &:r153_2, ~mu145_3 +# 153| m153_4(Point) = Store : &:r153_1, r153_3 +# 154| v154_1(void) = NoOp : +# 145| v145_10(void) = ReturnVoid : +# 145| v145_11(void) = UnmodeledUse : mu* +# 145| v145_12(void) = AliasedUse : ~mu145_3 +# 145| v145_13(void) = ExitFunction : + +# 156| void MergeMustTotallyOverlapWithMayPartiallyOverlap(bool, Rect, int) +# 156| Block 0 +# 156| v156_1(void) = EnterFunction : +# 156| mu156_2(unknown) = AliasedDefinition : +# 156| mu156_3(unknown) = UnmodeledDefinition : +# 156| r156_4(glval) = VariableAddress[c] : +# 156| m156_5(bool) = InitializeParameter[c] : &:r156_4 +# 156| r156_6(glval) = VariableAddress[r] : +# 156| m156_7(Rect) = InitializeParameter[r] : &:r156_6 +# 156| r156_8(glval) = VariableAddress[x1] : +# 156| m156_9(int) = InitializeParameter[x1] : &:r156_8 +# 157| r157_1(glval) = VariableAddress[a] : +# 157| mu157_2(Rect) = Uninitialized[a] : &:r157_1 +# 157| r157_3(glval) = FieldAddress[topLeft] : r157_1 +# 157| r157_4(Point) = Constant[0] : +# 157| mu157_5(Point) = Store : &:r157_3, r157_4 +# 157| r157_6(glval) = FieldAddress[bottomRight] : r157_1 +# 157| r157_7(Point) = Constant[0] : +# 157| mu157_8(Point) = Store : &:r157_6, r157_7 +# 158| r158_1(glval) = VariableAddress[c] : +# 158| r158_2(bool) = Load : &:r158_1, m156_5 +# 158| v158_3(void) = ConditionalBranch : r158_2 +#-----| False -> Block 2 +#-----| True -> Block 1 + +# 159| Block 1 +# 159| r159_1(glval) = VariableAddress[x1] : +# 159| r159_2(int) = Load : &:r159_1, m156_9 +# 159| r159_3(glval) = VariableAddress[a] : +# 159| r159_4(glval) = FieldAddress[topLeft] : r159_3 +# 159| r159_5(glval) = FieldAddress[x] : r159_4 +# 159| mu159_6(int) = Store : &:r159_5, r159_2 +#-----| Goto -> Block 3 + +# 162| Block 2 +# 162| r162_1(glval) = VariableAddress[r] : +# 162| r162_2(Rect) = Load : &:r162_1, m156_7 +# 162| r162_3(glval) = VariableAddress[a] : +# 162| mu162_4(Rect) = Store : &:r162_3, r162_2 +#-----| Goto -> Block 3 + +# 164| Block 3 +# 164| r164_1(glval) = VariableAddress[b] : +# 164| r164_2(glval) = VariableAddress[a] : +# 164| r164_3(glval) = FieldAddress[topLeft] : r164_2 +# 164| r164_4(Point) = Load : &:r164_3, ~mu156_3 +# 164| m164_5(Point) = Store : &:r164_1, r164_4 +# 165| v165_1(void) = NoOp : +# 156| v156_10(void) = ReturnVoid : +# 156| v156_11(void) = UnmodeledUse : mu* +# 156| v156_12(void) = AliasedUse : ~mu156_3 +# 156| v156_13(void) = ExitFunction : + +# 171| void WrapperStruct(Wrapper) +# 171| Block 0 +# 171| v171_1(void) = EnterFunction : +# 171| mu171_2(unknown) = AliasedDefinition : +# 171| mu171_3(unknown) = UnmodeledDefinition : +# 171| r171_4(glval) = VariableAddress[w] : +# 171| mu171_5(Wrapper) = InitializeParameter[w] : &:r171_4 +# 172| r172_1(glval) = VariableAddress[x] : +# 172| r172_2(glval) = VariableAddress[w] : +# 172| r172_3(Wrapper) = Load : &:r172_2, ~mu171_3 +# 172| m172_4(Wrapper) = Store : &:r172_1, r172_3 +# 173| r173_1(glval) = VariableAddress[a] : +# 173| r173_2(glval) = VariableAddress[w] : +# 173| r173_3(glval) = FieldAddress[f] : r173_2 +# 173| r173_4(int) = Load : &:r173_3, ~mu171_3 +# 173| m173_5(int) = Store : &:r173_1, r173_4 +# 174| r174_1(int) = Constant[5] : +# 174| r174_2(glval) = VariableAddress[w] : +# 174| r174_3(glval) = FieldAddress[f] : r174_2 +# 174| mu174_4(int) = Store : &:r174_3, r174_1 +# 175| r175_1(glval) = VariableAddress[w] : +# 175| r175_2(glval) = FieldAddress[f] : r175_1 +# 175| r175_3(int) = Load : &:r175_2, ~mu171_3 +# 175| r175_4(glval) = VariableAddress[a] : +# 175| m175_5(int) = Store : &:r175_4, r175_3 +# 176| r176_1(glval) = VariableAddress[w] : +# 176| r176_2(Wrapper) = Load : &:r176_1, ~mu171_3 +# 176| r176_3(glval) = VariableAddress[x] : +# 176| m176_4(Wrapper) = Store : &:r176_3, r176_2 +# 177| v177_1(void) = NoOp : +# 171| v171_6(void) = ReturnVoid : +# 171| v171_7(void) = UnmodeledUse : mu* +# 171| v171_8(void) = AliasedUse : ~mu171_3 +# 171| v171_9(void) = ExitFunction : + +# 179| int AsmStmt(int*) +# 179| Block 0 +# 179| v179_1(void) = EnterFunction : +# 179| mu179_2(unknown) = AliasedDefinition : +# 179| mu179_3(unknown) = UnmodeledDefinition : +# 179| r179_4(glval) = VariableAddress[p] : +# 179| m179_5(int *) = InitializeParameter[p] : &:r179_4 +# 179| r179_6(int *) = Load : &:r179_4, m179_5 +# 179| mu179_7(unknown) = InitializeIndirection[p] : &:r179_6 +# 180| mu180_1(unknown) = InlineAsm : ~mu179_3 +# 181| r181_1(glval) = VariableAddress[#return] : +# 181| r181_2(glval) = VariableAddress[p] : +# 181| r181_3(int *) = Load : &:r181_2, m179_5 +# 181| r181_4(int) = Load : &:r181_3, ~mu179_3 +# 181| m181_5(int) = Store : &:r181_1, r181_4 +# 179| v179_8(void) = ReturnIndirection : &:r179_6, ~mu179_3 +# 179| r179_9(glval) = VariableAddress[#return] : +# 179| v179_10(void) = ReturnValue : &:r179_9, m181_5 +# 179| v179_11(void) = UnmodeledUse : mu* +# 179| v179_12(void) = AliasedUse : ~mu179_3 +# 179| v179_13(void) = ExitFunction : + +# 184| void AsmStmtWithOutputs(unsigned int&, unsigned int&, unsigned int&, unsigned int&) +# 184| Block 0 +# 184| v184_1(void) = EnterFunction : +# 184| mu184_2(unknown) = AliasedDefinition : +# 184| mu184_3(unknown) = UnmodeledDefinition : +# 184| r184_4(glval) = VariableAddress[a] : +# 184| m184_5(unsigned int &) = InitializeParameter[a] : &:r184_4 +# 184| r184_6(unsigned int &) = Load : &:r184_4, m184_5 +# 184| mu184_7(unknown) = InitializeIndirection[a] : &:r184_6 +# 184| r184_8(glval) = VariableAddress[b] : +# 184| m184_9(unsigned int &) = InitializeParameter[b] : &:r184_8 +# 184| r184_10(unsigned int &) = Load : &:r184_8, m184_9 +# 184| mu184_11(unknown) = InitializeIndirection[b] : &:r184_10 +# 184| r184_12(glval) = VariableAddress[c] : +# 184| m184_13(unsigned int &) = InitializeParameter[c] : &:r184_12 +# 184| r184_14(unsigned int &) = Load : &:r184_12, m184_13 +# 184| mu184_15(unknown) = InitializeIndirection[c] : &:r184_14 +# 184| r184_16(glval) = VariableAddress[d] : +# 184| m184_17(unsigned int &) = InitializeParameter[d] : &:r184_16 +# 184| r184_18(unsigned int &) = Load : &:r184_16, m184_17 +# 184| mu184_19(unknown) = InitializeIndirection[d] : &:r184_18 +# 189| r189_1(glval) = VariableAddress[a] : +# 189| r189_2(unsigned int &) = Load : &:r189_1, m184_5 +# 189| r189_3(glval) = CopyValue : r189_2 +# 189| r189_4(glval) = VariableAddress[b] : +# 189| r189_5(unsigned int &) = Load : &:r189_4, m184_9 +# 189| r189_6(glval) = CopyValue : r189_5 +# 190| r190_1(glval) = VariableAddress[c] : +# 190| r190_2(unsigned int &) = Load : &:r190_1, m184_13 +# 190| r190_3(unsigned int) = Load : &:r190_2, ~mu184_3 +# 190| r190_4(glval) = VariableAddress[d] : +# 190| r190_5(unsigned int &) = Load : &:r190_4, m184_17 +# 190| r190_6(unsigned int) = Load : &:r190_5, ~mu184_3 +# 186| mu186_1(unknown) = InlineAsm : ~mu184_3, 0:r189_3, 1:r189_6, 2:r190_3, 3:r190_6 +# 192| v192_1(void) = NoOp : +# 184| v184_20(void) = ReturnIndirection : &:r184_6, ~mu184_3 +# 184| v184_21(void) = ReturnIndirection : &:r184_10, ~mu184_3 +# 184| v184_22(void) = ReturnIndirection : &:r184_14, ~mu184_3 +# 184| v184_23(void) = ReturnIndirection : &:r184_18, ~mu184_3 +# 184| v184_24(void) = ReturnVoid : +# 184| v184_25(void) = UnmodeledUse : mu* +# 184| v184_26(void) = AliasedUse : ~mu184_3 +# 184| v184_27(void) = ExitFunction : + +# 198| int PureFunctions(char*, char*, int) +# 198| Block 0 +# 198| v198_1(void) = EnterFunction : +# 198| mu198_2(unknown) = AliasedDefinition : +# 198| mu198_3(unknown) = UnmodeledDefinition : +# 198| r198_4(glval) = VariableAddress[str1] : +# 198| m198_5(char *) = InitializeParameter[str1] : &:r198_4 +# 198| r198_6(char *) = Load : &:r198_4, m198_5 +# 198| mu198_7(unknown) = InitializeIndirection[str1] : &:r198_6 +# 198| r198_8(glval) = VariableAddress[str2] : +# 198| m198_9(char *) = InitializeParameter[str2] : &:r198_8 +# 198| r198_10(char *) = Load : &:r198_8, m198_9 +# 198| mu198_11(unknown) = InitializeIndirection[str2] : &:r198_10 +# 198| r198_12(glval) = VariableAddress[x] : +# 198| m198_13(int) = InitializeParameter[x] : &:r198_12 +# 199| r199_1(glval) = VariableAddress[ret] : +# 199| r199_2(glval) = FunctionAddress[strcmp] : +# 199| r199_3(glval) = VariableAddress[str1] : +# 199| r199_4(char *) = Load : &:r199_3, m198_5 +# 199| r199_5(char *) = Convert : r199_4 +# 199| r199_6(glval) = VariableAddress[str2] : +# 199| r199_7(char *) = Load : &:r199_6, m198_9 +# 199| r199_8(char *) = Convert : r199_7 +# 199| r199_9(int) = Call : func:r199_2, 0:r199_5, 1:r199_8 +# 199| v199_10(void) = ^CallReadSideEffect : ~mu198_3 +# 199| m199_11(int) = Store : &:r199_1, r199_9 +# 200| r200_1(glval) = FunctionAddress[strlen] : +# 200| r200_2(glval) = VariableAddress[str1] : +# 200| r200_3(char *) = Load : &:r200_2, m198_5 +# 200| r200_4(char *) = Convert : r200_3 +# 200| r200_5(int) = Call : func:r200_1, 0:r200_4 +# 200| v200_6(void) = ^CallReadSideEffect : ~mu198_3 +# 200| r200_7(glval) = VariableAddress[ret] : +# 200| r200_8(int) = Load : &:r200_7, m199_11 +# 200| r200_9(int) = Add : r200_8, r200_5 +# 200| m200_10(int) = Store : &:r200_7, r200_9 +# 201| r201_1(glval) = FunctionAddress[abs] : +# 201| r201_2(glval) = VariableAddress[x] : +# 201| r201_3(int) = Load : &:r201_2, m198_13 +# 201| r201_4(int) = Call : func:r201_1, 0:r201_3 +# 201| r201_5(glval) = VariableAddress[ret] : +# 201| r201_6(int) = Load : &:r201_5, m200_10 +# 201| r201_7(int) = Add : r201_6, r201_4 +# 201| m201_8(int) = Store : &:r201_5, r201_7 +# 202| r202_1(glval) = VariableAddress[#return] : +# 202| r202_2(glval) = VariableAddress[ret] : +# 202| r202_3(int) = Load : &:r202_2, m201_8 +# 202| m202_4(int) = Store : &:r202_1, r202_3 +# 198| v198_14(void) = ReturnIndirection : &:r198_6, ~mu198_3 +# 198| v198_15(void) = ReturnIndirection : &:r198_10, ~mu198_3 +# 198| r198_16(glval) = VariableAddress[#return] : +# 198| v198_17(void) = ReturnValue : &:r198_16, m202_4 +# 198| v198_18(void) = UnmodeledUse : mu* +# 198| v198_19(void) = AliasedUse : ~mu198_3 +# 198| v198_20(void) = ExitFunction : + +# 207| int ModeledCallTarget(int) +# 207| Block 0 +# 207| v207_1(void) = EnterFunction : +# 207| mu207_2(unknown) = AliasedDefinition : +# 207| mu207_3(unknown) = UnmodeledDefinition : +# 207| r207_4(glval) = VariableAddress[x] : +# 207| mu207_5(int) = InitializeParameter[x] : &:r207_4 +# 208| r208_1(glval) = VariableAddress[y] : +# 208| mu208_2(int) = Uninitialized[y] : &:r208_1 +# 209| r209_1(glval) = FunctionAddress[memcpy] : +# 209| r209_2(glval) = VariableAddress[y] : +# 209| r209_3(int *) = CopyValue : r209_2 +# 209| r209_4(void *) = Convert : r209_3 +# 209| r209_5(glval) = VariableAddress[x] : +# 209| r209_6(int *) = CopyValue : r209_5 +# 209| r209_7(void *) = Convert : r209_6 +# 209| r209_8(int) = Constant[4] : +# 209| r209_9(void *) = Call : func:r209_1, 0:r209_4, 1:r209_7, 2:r209_8 +# 209| v209_10(void) = ^SizedBufferReadSideEffect[1] : &:r209_7, r209_8, ~mu207_3 +# 209| mu209_11(unknown) = ^SizedBufferMustWriteSideEffect[0] : &:r209_4, r209_8 +# 210| r210_1(glval) = VariableAddress[#return] : +# 210| r210_2(glval) = VariableAddress[y] : +# 210| r210_3(int) = Load : &:r210_2, ~mu207_3 +# 210| m210_4(int) = Store : &:r210_1, r210_3 +# 207| r207_6(glval) = VariableAddress[#return] : +# 207| v207_7(void) = ReturnValue : &:r207_6, m210_4 +# 207| v207_8(void) = UnmodeledUse : mu* +# 207| v207_9(void) = AliasedUse : ~mu207_3 +# 207| v207_10(void) = ExitFunction : + +# 213| void InitArray() +# 213| Block 0 +# 213| v213_1(void) = EnterFunction : +# 213| mu213_2(unknown) = AliasedDefinition : +# 213| mu213_3(unknown) = UnmodeledDefinition : +# 214| r214_1(glval) = VariableAddress[a_pad] : +# 214| r214_2(glval) = StringConstant[""] : +# 214| r214_3(char[32]) = Load : &:r214_2, ~mu213_3 +# 214| m214_4(char[32]) = Store : &:r214_1, r214_3 +# 215| r215_1(glval) = VariableAddress[a_nopad] : +# 215| r215_2(glval) = StringConstant["foo"] : +# 215| r215_3(char[4]) = Load : &:r215_2, ~mu213_3 +# 215| m215_4(char[4]) = Store : &:r215_1, r215_3 +# 216| r216_1(glval) = VariableAddress[a_infer] : +# 216| r216_2(glval) = StringConstant["blah"] : +# 216| r216_3(char[5]) = Load : &:r216_2, ~mu213_3 +# 216| m216_4(char[5]) = Store : &:r216_1, r216_3 +# 217| r217_1(glval) = VariableAddress[b] : +# 217| m217_2(char[2]) = Uninitialized[b] : &:r217_1 +# 218| r218_1(glval) = VariableAddress[c] : +# 218| mu218_2(char[2]) = Uninitialized[c] : &:r218_1 +# 218| r218_3(int) = Constant[0] : +# 218| r218_4(glval) = PointerAdd[1] : r218_1, r218_3 +# 218| r218_5(unknown[2]) = Constant[0] : +# 218| mu218_6(unknown[2]) = Store : &:r218_4, r218_5 +# 219| r219_1(glval) = VariableAddress[d] : +# 219| mu219_2(char[2]) = Uninitialized[d] : &:r219_1 +# 219| r219_3(int) = Constant[0] : +# 219| r219_4(glval) = PointerAdd[1] : r219_1, r219_3 +# 219| r219_5(char) = Constant[0] : +# 219| mu219_6(char) = Store : &:r219_4, r219_5 +# 219| r219_7(int) = Constant[1] : +# 219| r219_8(glval) = PointerAdd[1] : r219_1, r219_7 +# 219| r219_9(char) = Constant[0] : +# 219| mu219_10(char) = Store : &:r219_8, r219_9 +# 220| r220_1(glval) = VariableAddress[e] : +# 220| mu220_2(char[2]) = Uninitialized[e] : &:r220_1 +# 220| r220_3(int) = Constant[0] : +# 220| r220_4(glval) = PointerAdd[1] : r220_1, r220_3 +# 220| r220_5(char) = Constant[0] : +# 220| mu220_6(char) = Store : &:r220_4, r220_5 +# 220| r220_7(int) = Constant[1] : +# 220| r220_8(glval) = PointerAdd[1] : r220_1, r220_7 +# 220| r220_9(char) = Constant[1] : +# 220| mu220_10(char) = Store : &:r220_8, r220_9 +# 221| r221_1(glval) = VariableAddress[f] : +# 221| mu221_2(char[3]) = Uninitialized[f] : &:r221_1 +# 221| r221_3(int) = Constant[0] : +# 221| r221_4(glval) = PointerAdd[1] : r221_1, r221_3 +# 221| r221_5(char) = Constant[0] : +# 221| mu221_6(char) = Store : &:r221_4, r221_5 +# 221| r221_7(int) = Constant[1] : +# 221| r221_8(glval) = PointerAdd[1] : r221_1, r221_7 +# 221| r221_9(unknown[2]) = Constant[0] : +# 221| mu221_10(unknown[2]) = Store : &:r221_8, r221_9 +# 222| v222_1(void) = NoOp : +# 213| v213_4(void) = ReturnVoid : +# 213| v213_5(void) = UnmodeledUse : mu* +# 213| v213_6(void) = AliasedUse : ~mu213_3 +# 213| v213_7(void) = ExitFunction : + +# 226| char StringLiteralAliasing() +# 226| Block 0 +# 226| v226_1(void) = EnterFunction : +# 226| mu226_2(unknown) = AliasedDefinition : +# 226| mu226_3(unknown) = UnmodeledDefinition : +# 227| r227_1(glval) = FunctionAddress[ExternalFunc] : +# 227| v227_2(void) = Call : func:r227_1 +# 227| mu227_3(unknown) = ^CallSideEffect : ~mu226_3 +# 229| r229_1(glval) = VariableAddress[s] : +# 229| r229_2(glval) = StringConstant["Literal"] : +# 229| r229_3(char *) = Convert : r229_2 +# 229| m229_4(char *) = Store : &:r229_1, r229_3 +# 230| r230_1(glval) = VariableAddress[#return] : +# 230| r230_2(glval) = VariableAddress[s] : +# 230| r230_3(char *) = Load : &:r230_2, m229_4 +# 230| r230_4(int) = Constant[2] : +# 230| r230_5(glval) = PointerAdd[1] : r230_3, r230_4 +# 230| r230_6(char) = Load : &:r230_5, ~mu226_3 +# 230| m230_7(char) = Store : &:r230_1, r230_6 +# 226| r226_4(glval) = VariableAddress[#return] : +# 226| v226_5(void) = ReturnValue : &:r226_4, m230_7 +# 226| v226_6(void) = UnmodeledUse : mu* +# 226| v226_7(void) = AliasedUse : ~mu226_3 +# 226| v226_8(void) = ExitFunction : + +# 235| void Constructible::Constructible(int) +# 235| Block 0 +# 235| v235_1(void) = EnterFunction : +# 235| mu235_2(unknown) = AliasedDefinition : +# 235| mu235_3(unknown) = UnmodeledDefinition : +# 235| r235_4(glval) = InitializeThis : +# 235| r235_5(glval) = VariableAddress[x] : +# 235| m235_6(int) = InitializeParameter[x] : &:r235_5 +# 235| v235_7(void) = NoOp : +# 235| v235_8(void) = ReturnVoid : +# 235| v235_9(void) = UnmodeledUse : mu* +# 235| v235_10(void) = AliasedUse : ~mu235_3 +# 235| v235_11(void) = ExitFunction : + +# 236| void Constructible::g() +# 236| Block 0 +# 236| v236_1(void) = EnterFunction : +# 236| mu236_2(unknown) = AliasedDefinition : +# 236| mu236_3(unknown) = UnmodeledDefinition : +# 236| r236_4(glval) = InitializeThis : +# 236| v236_5(void) = NoOp : +# 236| v236_6(void) = ReturnVoid : +# 236| v236_7(void) = UnmodeledUse : mu* +# 236| v236_8(void) = AliasedUse : ~mu236_3 +# 236| v236_9(void) = ExitFunction : + +# 239| void ExplicitConstructorCalls() +# 239| Block 0 +# 239| v239_1(void) = EnterFunction : +# 239| mu239_2(unknown) = AliasedDefinition : +# 239| mu239_3(unknown) = UnmodeledDefinition : +# 240| r240_1(glval) = VariableAddress[c] : +# 240| mu240_2(Constructible) = Uninitialized[c] : &:r240_1 +# 240| r240_3(glval) = FunctionAddress[Constructible] : +# 240| r240_4(int) = Constant[1] : +# 240| v240_5(void) = Call : func:r240_3, this:r240_1, 0:r240_4 +# 240| mu240_6(unknown) = ^CallSideEffect : ~mu239_3 +# 240| mu240_7(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r240_1 +# 241| r241_1(glval) = VariableAddress[c] : +# 241| r241_2(glval) = FunctionAddress[g] : +# 241| v241_3(void) = Call : func:r241_2, this:r241_1 +# 241| mu241_4(unknown) = ^CallSideEffect : ~mu239_3 +# 241| v241_5(void) = ^BufferReadSideEffect[-1] : &:r241_1, ~mu239_3 +# 241| mu241_6(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r241_1 +# 242| r242_1(glval) = VariableAddress[c] : +# 242| r242_2(glval) = FunctionAddress[g] : +# 242| v242_3(void) = Call : func:r242_2, this:r242_1 +# 242| mu242_4(unknown) = ^CallSideEffect : ~mu239_3 +# 242| v242_5(void) = ^BufferReadSideEffect[-1] : &:r242_1, ~mu239_3 +# 242| mu242_6(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r242_1 +# 243| r243_1(glval) = VariableAddress[c2] : +# 243| mu243_2(Constructible) = Uninitialized[c2] : &:r243_1 +# 243| r243_3(glval) = FunctionAddress[Constructible] : +# 243| r243_4(int) = Constant[2] : +# 243| v243_5(void) = Call : func:r243_3, this:r243_1, 0:r243_4 +# 243| mu243_6(unknown) = ^CallSideEffect : ~mu239_3 +# 243| mu243_7(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r243_1 +# 244| r244_1(glval) = VariableAddress[c2] : +# 244| r244_2(glval) = FunctionAddress[g] : +# 244| v244_3(void) = Call : func:r244_2, this:r244_1 +# 244| mu244_4(unknown) = ^CallSideEffect : ~mu239_3 +# 244| v244_5(void) = ^BufferReadSideEffect[-1] : &:r244_1, ~mu239_3 +# 244| mu244_6(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r244_1 +# 245| v245_1(void) = NoOp : +# 239| v239_4(void) = ReturnVoid : +# 239| v239_5(void) = UnmodeledUse : mu* +# 239| v239_6(void) = AliasedUse : ~mu239_3 +# 239| v239_7(void) = ExitFunction : diff --git a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir_unsound.qlref b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir_unsound.qlref new file mode 100644 index 00000000000..3f776444036 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir_unsound.qlref @@ -0,0 +1 @@ +semmle/code/cpp/ir/implementation/unaliased_ssa/PrintIR.ql \ No newline at end of file diff --git a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_sanity.ql b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_sanity.ql new file mode 100644 index 00000000000..c7d0ba957af --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_sanity.ql @@ -0,0 +1,2 @@ +import semmle.code.cpp.ir.implementation.unaliased_ssa.IRSanity +import semmle.code.cpp.ir.implementation.UseSoundEscapeAnalysis diff --git a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_sanity_unsound.expected b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_sanity_unsound.expected new file mode 100644 index 00000000000..9769ee11f99 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_sanity_unsound.expected @@ -0,0 +1,22 @@ +missingOperand +unexpectedOperand +duplicateOperand +missingPhiOperand +missingOperandType +duplicateChiOperand +sideEffectWithoutPrimary +instructionWithoutSuccessor +ambiguousSuccessors +unexplainedLoop +unnecessaryPhiInstruction +operandAcrossFunctions +instructionWithoutUniqueBlock +containsLoopOfForwardEdges +lostReachability +backEdgeCountMismatch +useNotDominatedByDefinition +missingCanonicalLanguageType +multipleCanonicalLanguageTypes +missingIRType +multipleIRTypes +missingCppType diff --git a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_sanity.qlref b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_sanity_unsound.qlref similarity index 100% rename from cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_sanity.qlref rename to cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_sanity_unsound.qlref diff --git a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ssa_sanity.ql b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ssa_sanity.ql new file mode 100644 index 00000000000..120881bf018 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ssa_sanity.ql @@ -0,0 +1,2 @@ +import semmle.code.cpp.ir.implementation.unaliased_ssa.internal.SSASanity +import semmle.code.cpp.ir.implementation.UseSoundEscapeAnalysis diff --git a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ssa_sanity_unsound.expected b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ssa_sanity_unsound.expected new file mode 100644 index 00000000000..7c2d1faf639 --- /dev/null +++ b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ssa_sanity_unsound.expected @@ -0,0 +1,2 @@ +multipleOperandMemoryLocations +missingVirtualVariableForMemoryLocation diff --git a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ssa_sanity.qlref b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ssa_sanity_unsound.qlref similarity index 100% rename from cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ssa_sanity.qlref rename to cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ssa_sanity_unsound.qlref diff --git a/csharp/ql/src/semmle/code/csharp/ir/implementation/IRConfiguration.qll b/csharp/ql/src/semmle/code/csharp/ir/implementation/IRConfiguration.qll index 67f9cd5bc62..c0a489ef0c6 100644 --- a/csharp/ql/src/semmle/code/csharp/ir/implementation/IRConfiguration.qll +++ b/csharp/ql/src/semmle/code/csharp/ir/implementation/IRConfiguration.qll @@ -17,3 +17,18 @@ class IRConfiguration extends TIRConfiguration { */ predicate shouldCreateIRForFunction(Language::Function func) { any() } } + +private newtype TIREscapeAnalysisConfiguration = MkIREscapeAnalysisConfiguration() + +/** + * The query can extend this class to control what escape analysis is used when generating SSA. + */ +class IREscapeAnalysisConfiguration extends TIREscapeAnalysisConfiguration { + string toString() { result = "IREscapeAnalysisConfiguration" } + + /** + * Holds if the escape analysis done by SSA construction should be sound. By default, the SSA is + * built assuming that no variable's address ever escapes. + */ + predicate useSoundEscapeAnalysis() { none() } +} diff --git a/csharp/ql/src/semmle/code/csharp/ir/implementation/UseSoundEscapeAnalysis.qll b/csharp/ql/src/semmle/code/csharp/ir/implementation/UseSoundEscapeAnalysis.qll new file mode 100644 index 00000000000..b9b1dc243b1 --- /dev/null +++ b/csharp/ql/src/semmle/code/csharp/ir/implementation/UseSoundEscapeAnalysis.qll @@ -0,0 +1,9 @@ +import IRConfiguration + +/** + * Overrides the default IR configuration to use sound escape analysis, instead of assuming that + * variable addresses never escape. + */ +class SoundEscapeAnalysisConfiguration extends IREscapeAnalysisConfiguration { + override predicate useSoundEscapeAnalysis() { any() } +} diff --git a/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/PrintSSA.qll b/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/PrintSSA.qll index 23121523a6b..94470fe8584 100644 --- a/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/PrintSSA.qll +++ b/csharp/ql/src/semmle/code/csharp/ir/implementation/unaliased_ssa/internal/PrintSSA.qll @@ -107,7 +107,7 @@ class PropertyProvider extends IRPropertyProvider { exists( MemoryLocation useLocation, IRBlock predBlock, IRBlock defBlock, int defIndex, Overlap overlap | - hasPhiOperandDefinition(_, useLocation, block, predBlock, defBlock, defIndex, overlap) and + hasPhiOperandDefinition(_, useLocation, block, predBlock, defBlock, defIndex) and key = "PhiUse[" + useLocation.toString() + " from " + predBlock.getDisplayIndex().toString() + "]" and result = defBlock.getDisplayIndex().toString() + "_" + defIndex + " (" + overlap.toString() + From 5ae1e2c4e849510c43c0e96f2204430d8e3eee7d Mon Sep 17 00:00:00 2001 From: Jonas Jensen Date: Wed, 22 Jan 2020 14:07:55 +0100 Subject: [PATCH 2/6] C++: Autoformat --- .../implementation/aliased_ssa/internal/AliasAnalysis.qll | 4 +--- .../cpp/ir/implementation/raw/internal/TranslatedExpr.qll | 8 ++------ .../cpp/ir/implementation/raw/internal/TranslatedStmt.qll | 4 +--- .../unaliased_ssa/internal/AliasAnalysis.qll | 4 +--- 4 files changed, 5 insertions(+), 15 deletions(-) diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/AliasAnalysis.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/AliasAnalysis.qll index 85b66cdca19..99f6b545806 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/AliasAnalysis.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/aliased_ssa/internal/AliasAnalysis.qll @@ -280,9 +280,7 @@ private predicate automaticVariableAddressEscapes(IRAutomaticVariable var) { predicate variableAddressEscapes(IRVariable var) { exists(IREscapeAnalysisConfiguration config | config.useSoundEscapeAnalysis() and - ( - automaticVariableAddressEscapes(var.(IRAutomaticVariable)) - ) + automaticVariableAddressEscapes(var.(IRAutomaticVariable)) ) or // All variables with static storage duration have their address escape, even when escape analysis 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 384d724eef9..84e3802c4a5 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 @@ -1947,9 +1947,7 @@ class TranslatedThrowValueExpr extends TranslatedThrowExpr, TranslatedVariableIn result = TranslatedVariableInitialization.super.getInstructionSuccessor(tag, kind) } - final override Instruction getInitializationSuccessor() { - result = getInstruction(ThrowTag()) - } + final override Instruction getInitializationSuccessor() { result = getInstruction(ThrowTag()) } final override predicate hasTempVariable(TempVariableTag tag, CppType type) { tag = ThrowTempVar() and @@ -1981,9 +1979,7 @@ class TranslatedThrowValueExpr extends TranslatedThrowExpr, TranslatedVariableIn result = getTranslatedInitialization(expr.getExpr().getFullyConverted()) } - final override IRVariable getIRVariable() { - result = getIRTempVariable(expr, ThrowTempVar()) - } + final override IRVariable getIRVariable() { result = getIRTempVariable(expr, ThrowTempVar()) } final override Opcode getThrowOpcode() { result instanceof Opcode::ThrowValue } diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedStmt.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedStmt.qll index 7458f2e104d..8bb5961248f 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedStmt.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/raw/internal/TranslatedStmt.qll @@ -143,9 +143,7 @@ class TranslatedReturnValueStmt extends TranslatedReturnStmt, TranslatedVariable result = getTranslatedInitialization(stmt.getExpr().getFullyConverted()) } - final override IRVariable getIRVariable() { - result = getEnclosingFunction().getReturnVariable() - } + final override IRVariable getIRVariable() { result = getEnclosingFunction().getReturnVariable() } } class TranslatedReturnVoidStmt extends TranslatedReturnStmt { diff --git a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/AliasAnalysis.qll b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/AliasAnalysis.qll index 85b66cdca19..99f6b545806 100644 --- a/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/AliasAnalysis.qll +++ b/cpp/ql/src/semmle/code/cpp/ir/implementation/unaliased_ssa/internal/AliasAnalysis.qll @@ -280,9 +280,7 @@ private predicate automaticVariableAddressEscapes(IRAutomaticVariable var) { predicate variableAddressEscapes(IRVariable var) { exists(IREscapeAnalysisConfiguration config | config.useSoundEscapeAnalysis() and - ( - automaticVariableAddressEscapes(var.(IRAutomaticVariable)) - ) + automaticVariableAddressEscapes(var.(IRAutomaticVariable)) ) or // All variables with static storage duration have their address escape, even when escape analysis From 66914e52c66de30bd834dba05ada98c7b2ebd039 Mon Sep 17 00:00:00 2001 From: Jonas Jensen Date: Wed, 22 Jan 2020 14:08:05 +0100 Subject: [PATCH 3/6] C++: accept test changes --- .../library-tests/dataflow/dataflow-tests/test_diff.expected | 2 -- .../library-tests/dataflow/dataflow-tests/test_ir.expected | 3 +++ .../test/library-tests/dataflow/taint-tests/test_diff.expected | 2 -- .../test/library-tests/dataflow/taint-tests/test_ir.expected | 2 ++ .../rangeanalysis/signanalysis/SignAnalysis.expected | 3 +-- .../test/library-tests/syntax-zoo/aliased_ssa_sanity.expected | 1 - 6 files changed, 6 insertions(+), 7 deletions(-) diff --git a/cpp/ql/test/library-tests/dataflow/dataflow-tests/test_diff.expected b/cpp/ql/test/library-tests/dataflow/dataflow-tests/test_diff.expected index fdfddb07ed6..0e8145588fe 100644 --- a/cpp/ql/test/library-tests/dataflow/dataflow-tests/test_diff.expected +++ b/cpp/ql/test/library-tests/dataflow/dataflow-tests/test_diff.expected @@ -1,7 +1,6 @@ | BarrierGuard.cpp:60:11:60:16 | BarrierGuard.cpp:62:14:62:14 | AST only | | BarrierGuard.cpp:60:11:60:16 | BarrierGuard.cpp:64:14:64:14 | AST only | | BarrierGuard.cpp:60:11:60:16 | BarrierGuard.cpp:66:14:66:14 | AST only | -| clang.cpp:12:9:12:20 | clang.cpp:18:8:18:19 | AST only | | clang.cpp:12:9:12:20 | clang.cpp:22:8:22:20 | AST only | | clang.cpp:28:27:28:32 | clang.cpp:29:27:29:28 | AST only | | clang.cpp:28:27:28:32 | clang.cpp:30:27:30:34 | AST only | @@ -22,7 +21,6 @@ | lambdas.cpp:8:10:8:15 | lambdas.cpp:18:8:18:8 | AST only | | lambdas.cpp:8:10:8:15 | lambdas.cpp:21:3:21:6 | AST only | | lambdas.cpp:8:10:8:15 | lambdas.cpp:29:3:29:6 | AST only | -| lambdas.cpp:8:10:8:15 | lambdas.cpp:35:8:35:8 | AST only | | lambdas.cpp:8:10:8:15 | lambdas.cpp:41:8:41:8 | AST only | | lambdas.cpp:43:7:43:12 | lambdas.cpp:46:7:46:7 | AST only | | ref.cpp:29:11:29:16 | ref.cpp:62:10:62:11 | AST only | diff --git a/cpp/ql/test/library-tests/dataflow/dataflow-tests/test_ir.expected b/cpp/ql/test/library-tests/dataflow/dataflow-tests/test_ir.expected index ea980b3b1a0..4dbcbdd71a9 100644 --- a/cpp/ql/test/library-tests/dataflow/dataflow-tests/test_ir.expected +++ b/cpp/ql/test/library-tests/dataflow/dataflow-tests/test_ir.expected @@ -7,6 +7,8 @@ | BarrierGuard.cpp:55:13:55:13 | x | BarrierGuard.cpp:49:10:49:15 | call to source | | acrossLinkTargets.cpp:12:8:12:8 | (int)... | acrossLinkTargets.cpp:19:27:19:32 | call to source | | acrossLinkTargets.cpp:12:8:12:8 | x | acrossLinkTargets.cpp:19:27:19:32 | call to source | +| clang.cpp:18:8:18:19 | (const int *)... | clang.cpp:12:9:12:20 | sourceArray1 | +| clang.cpp:18:8:18:19 | sourceArray1 | clang.cpp:12:9:12:20 | sourceArray1 | | clang.cpp:37:10:37:11 | m2 | clang.cpp:34:32:34:37 | call to source | | clang.cpp:41:18:41:19 | m2 | clang.cpp:39:42:39:47 | call to source | | clang.cpp:45:17:45:18 | m2 | clang.cpp:43:35:43:40 | call to source | @@ -28,6 +30,7 @@ | dispatch.cpp:55:22:55:30 | call to isSource1 | dispatch.cpp:22:37:22:42 | call to source | | dispatch.cpp:58:28:58:36 | call to isSource1 | dispatch.cpp:22:37:22:42 | call to source | | dispatch.cpp:96:8:96:8 | x | dispatch.cpp:107:17:107:22 | call to source | +| lambdas.cpp:35:8:35:8 | a | lambdas.cpp:8:10:8:15 | call to source | | test.cpp:7:8:7:9 | t1 | test.cpp:6:12:6:17 | call to source | | test.cpp:9:8:9:9 | t1 | test.cpp:6:12:6:17 | call to source | | test.cpp:10:8:10:9 | t2 | test.cpp:6:12:6:17 | call to source | diff --git a/cpp/ql/test/library-tests/dataflow/taint-tests/test_diff.expected b/cpp/ql/test/library-tests/dataflow/taint-tests/test_diff.expected index 2531ccda8a1..60ef72073f4 100644 --- a/cpp/ql/test/library-tests/dataflow/taint-tests/test_diff.expected +++ b/cpp/ql/test/library-tests/dataflow/taint-tests/test_diff.expected @@ -13,13 +13,11 @@ | taint.cpp:181:8:181:9 | taint.cpp:185:11:185:16 | AST only | | taint.cpp:195:7:195:7 | taint.cpp:192:23:192:28 | AST only | | taint.cpp:195:7:195:7 | taint.cpp:193:6:193:6 | AST only | -| taint.cpp:215:7:215:7 | taint.cpp:207:6:207:11 | AST only | | taint.cpp:216:7:216:7 | taint.cpp:207:6:207:11 | AST only | | taint.cpp:229:3:229:6 | taint.cpp:223:10:223:15 | AST only | | taint.cpp:233:8:233:8 | taint.cpp:223:10:223:15 | AST only | | taint.cpp:236:3:236:6 | taint.cpp:223:10:223:15 | AST only | | taint.cpp:244:3:244:6 | taint.cpp:223:10:223:15 | AST only | -| taint.cpp:250:8:250:8 | taint.cpp:223:10:223:15 | AST only | | taint.cpp:256:8:256:8 | taint.cpp:223:10:223:15 | AST only | | taint.cpp:261:7:261:7 | taint.cpp:258:7:258:12 | AST only | | taint.cpp:351:7:351:7 | taint.cpp:330:6:330:11 | AST only | diff --git a/cpp/ql/test/library-tests/dataflow/taint-tests/test_ir.expected b/cpp/ql/test/library-tests/dataflow/taint-tests/test_ir.expected index 81195e197c1..56fd106e503 100644 --- a/cpp/ql/test/library-tests/dataflow/taint-tests/test_ir.expected +++ b/cpp/ql/test/library-tests/dataflow/taint-tests/test_ir.expected @@ -9,6 +9,8 @@ | taint.cpp:167:8:167:13 | call to source | taint.cpp:167:8:167:13 | call to source | | taint.cpp:168:8:168:14 | tainted | taint.cpp:164:19:164:24 | call to source | | taint.cpp:210:7:210:7 | x | taint.cpp:207:6:207:11 | call to source | +| taint.cpp:215:7:215:7 | x | taint.cpp:207:6:207:11 | call to source | +| taint.cpp:250:8:250:8 | a | taint.cpp:223:10:223:15 | call to source | | taint.cpp:280:7:280:7 | t | taint.cpp:275:6:275:11 | call to source | | taint.cpp:289:7:289:7 | t | taint.cpp:275:6:275:11 | call to source | | taint.cpp:290:7:290:7 | x | taint.cpp:275:6:275:11 | call to source | diff --git a/cpp/ql/test/library-tests/rangeanalysis/signanalysis/SignAnalysis.expected b/cpp/ql/test/library-tests/rangeanalysis/signanalysis/SignAnalysis.expected index c8a276b1f63..e4a2cc3d774 100644 --- a/cpp/ql/test/library-tests/rangeanalysis/signanalysis/SignAnalysis.expected +++ b/cpp/ql/test/library-tests/rangeanalysis/signanalysis/SignAnalysis.expected @@ -16,8 +16,7 @@ | inline_assembly.c:10:3:10:7 | Store: ... = ... | positive strictlyPositive | | inline_assembly.c:10:7:10:7 | Constant: (unsigned int)... | positive strictlyPositive | | inline_assembly.c:12:32:12:32 | Load: y | positive strictlyPositive | -| inline_assembly.c:21:29:21:29 | Load: x | positive | -| inline_assembly.c:21:32:21:32 | Load: y | positive | +| inline_assembly.c:21:32:21:32 | Load: y | positive strictlyPositive | | minmax.c:16:9:16:10 | Constant: 1 | positive strictlyPositive | | minmax.c:16:9:16:10 | Store: 1 | positive strictlyPositive | | minmax.c:16:16:16:17 | Constant: 2 | positive strictlyPositive | diff --git a/cpp/ql/test/library-tests/syntax-zoo/aliased_ssa_sanity.expected b/cpp/ql/test/library-tests/syntax-zoo/aliased_ssa_sanity.expected index 2fad91f5f85..ebd22e357c2 100644 --- a/cpp/ql/test/library-tests/syntax-zoo/aliased_ssa_sanity.expected +++ b/cpp/ql/test/library-tests/syntax-zoo/aliased_ssa_sanity.expected @@ -27,7 +27,6 @@ missingOperand | ir.cpp:823:7:823:13 | IndirectMayWriteSideEffect: call to Base | Instruction 'IndirectMayWriteSideEffect' is missing an expected operand with tag 'Address' in function '$@'. | ir.cpp:799:6:799:25 | IR: HierarchyConversions | void HierarchyConversions() | | ir.cpp:824:7:824:26 | IndirectMayWriteSideEffect: call to Base | Instruction 'IndirectMayWriteSideEffect' is missing an expected operand with tag 'Address' in function '$@'. | ir.cpp:799:6:799:25 | IR: HierarchyConversions | void HierarchyConversions() | | misc.c:125:5:125:11 | CopyValue: (statement expression) | Instruction 'CopyValue' is missing an expected operand with tag 'Unary' in function '$@'. | misc.c:97:6:97:10 | IR: misc3 | void misc3() | -| try_catch.cpp:13:5:13:16 | Chi: call to exn1 | Instruction 'Chi' is missing an expected operand with tag 'ChiTotal' in function '$@'. | try_catch.cpp:11:6:11:17 | IR: bypass_catch | void bypass_catch() | unexpectedOperand duplicateOperand missingPhiOperand From 708e83546f71dcaed9b3e3cc35098b5631cba476 Mon Sep 17 00:00:00 2001 From: Dave Bartolomeo Date: Sun, 26 Jan 2020 16:20:27 -0700 Subject: [PATCH 4/6] C++: Remove acceidentally added tests --- .../ir/ir/aliased_ssa_ir.expected | 6200 ----------------- .../library-tests/ir/ir/aliased_ssa_ir.qlref | 1 - .../ir/ir/unaliased_ssa_ir.expected | 5926 ---------------- .../ir/ir/unaliased_ssa_ir.qlref | 1 - 4 files changed, 12128 deletions(-) delete mode 100644 cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.expected delete mode 100644 cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.qlref delete mode 100644 cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.expected delete mode 100644 cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.qlref 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 deleted file mode 100644 index be344e731a8..00000000000 --- a/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.expected +++ /dev/null @@ -1,6200 +0,0 @@ -bad_asts.cpp: -# 9| int Bad::S::MemberFunction(int) -# 9| Block 0 -# 9| v9_1(void) = EnterFunction : -# 9| m9_2(unknown) = AliasedDefinition : -# 9| mu9_3(unknown) = UnmodeledDefinition : -# 9| r9_4(glval) = InitializeThis : -# 9| r9_5(glval) = VariableAddress[y] : -# 9| m9_6(int) = InitializeParameter[y] : &:r9_5 -# 10| r10_1(glval) = VariableAddress[#return] : -# 10| r10_2(int) = Constant[6] : -#-----| r0_1(S *) = CopyValue : r9_4 -# 10| r10_3(glval) = FieldAddress[x] : r0_1 -# 10| r10_4(int) = Load : &:r10_3, ~m9_2 -# 10| r10_5(int) = Add : r10_2, r10_4 -# 10| r10_6(glval) = VariableAddress[y] : -# 10| r10_7(int) = Load : &:r10_6, m9_6 -# 10| r10_8(int) = Add : r10_5, r10_7 -# 10| m10_9(int) = Store : &:r10_1, r10_8 -# 9| r9_7(glval) = VariableAddress[#return] : -# 9| v9_8(void) = ReturnValue : &:r9_7, m10_9 -# 9| v9_9(void) = UnmodeledUse : mu* -# 9| v9_10(void) = AliasedUse : ~m9_2 -# 9| v9_11(void) = ExitFunction : - -# 14| void Bad::CallBadMemberFunction() -# 14| Block 0 -# 14| v14_1(void) = EnterFunction : -# 14| m14_2(unknown) = AliasedDefinition : -# 14| mu14_3(unknown) = UnmodeledDefinition : -# 15| r15_1(glval) = VariableAddress[s] : -# 15| m15_2(S) = Uninitialized[s] : &:r15_1 -# 15| r15_3(glval) = FieldAddress[x] : r15_1 -# 15| r15_4(int) = Constant[0] : -# 15| m15_5(int) = Store : &:r15_3, r15_4 -# 16| r16_1(glval) = VariableAddress[s] : -# 16| r16_2(glval) = FunctionAddress[MemberFunction] : -# 16| r16_3(int) = Constant[1] : -# 16| r16_4(int) = Call : func:r16_2, this:r16_1, 0:r16_3 -# 16| m16_5(unknown) = ^CallSideEffect : ~m14_2 -# 16| m16_6(unknown) = Chi : total:m14_2, partial:m16_5 -# 16| v16_7(void) = ^BufferReadSideEffect[-1] : &:r16_1, ~m15_5 -# 16| m16_8(S) = ^IndirectMayWriteSideEffect[-1] : &:r16_1 -# 16| m16_9(S) = Chi : total:m15_5, partial:m16_8 -# 17| v17_1(void) = NoOp : -# 14| v14_4(void) = ReturnVoid : -# 14| v14_5(void) = UnmodeledUse : mu* -# 14| v14_6(void) = AliasedUse : ~m16_6 -# 14| v14_7(void) = ExitFunction : - -# 22| void Bad::Point::Point() -# 22| Block 0 -# 22| v22_1(void) = EnterFunction : -# 22| m22_2(unknown) = AliasedDefinition : -# 22| mu22_3(unknown) = UnmodeledDefinition : -# 22| r22_4(glval) = InitializeThis : -# 23| v23_1(void) = NoOp : -# 22| v22_5(void) = ReturnVoid : -# 22| v22_6(void) = UnmodeledUse : mu* -# 22| v22_7(void) = AliasedUse : ~m22_2 -# 22| v22_8(void) = ExitFunction : - -# 26| void Bad::CallCopyConstructor(Bad::Point const&) -# 26| Block 0 -# 26| v26_1(void) = EnterFunction : -# 26| m26_2(unknown) = AliasedDefinition : -# 26| mu26_3(unknown) = UnmodeledDefinition : -# 26| r26_4(glval) = VariableAddress[a] : -# 26| m26_5(Point &) = InitializeParameter[a] : &:r26_4 -# 26| r26_6(Point &) = Load : &:r26_4, m26_5 -# 26| m26_7(unknown) = InitializeIndirection[a] : &:r26_6 -# 26| m26_8(unknown) = Chi : total:m26_2, partial:m26_7 -# 27| r27_1(glval) = VariableAddress[b] : -# 27| r27_2(glval) = VariableAddress[a] : -# 27| r27_3(Point &) = Load : &:r27_2, m26_5 -# 27| r27_4(glval) = CopyValue : r27_3 -# 27| r27_5(glval) = Convert : r27_4 -# 27| r27_6(Point) = Load : &:r27_5, ~m26_8 -# 27| m27_7(Point) = Store : &:r27_1, r27_6 -# 28| v28_1(void) = NoOp : -# 26| v26_9(void) = ReturnIndirection : &:r26_6, ~m26_8 -# 26| v26_10(void) = ReturnVoid : -# 26| v26_11(void) = UnmodeledUse : mu* -# 26| v26_12(void) = AliasedUse : ~m26_8 -# 26| v26_13(void) = ExitFunction : - -# 30| void Bad::errorExpr() -# 30| Block 0 -# 30| v30_1(void) = EnterFunction : -# 30| m30_2(unknown) = AliasedDefinition : -# 30| mu30_3(unknown) = UnmodeledDefinition : -# 31| r31_1(glval) = VariableAddress[intref] : -# 31| r31_2(error) = Error : -# 31| m31_3(int &) = Store : &:r31_1, r31_2 -# 32| r32_1(glval) = VariableAddress[x] : -# 32| r32_2(error) = Error : -# 32| m32_3(int) = Store : &:r32_1, r32_2 -#-----| r0_1(glval) = Error : -#-----| r0_2(error) = Load : &:r0_1, ~m30_2 -# 33| r33_1(glval) = VariableAddress[x] : -# 33| m33_2(int) = Store : &:r33_1, r0_2 -# 34| v34_1(void) = NoOp : -# 30| v30_4(void) = ReturnVoid : -# 30| v30_5(void) = UnmodeledUse : mu* -# 30| v30_6(void) = AliasedUse : ~m30_2 -# 30| v30_7(void) = ExitFunction : - -clang.cpp: -# 5| int* globalIntAddress() -# 5| Block 0 -# 5| v5_1(void) = EnterFunction : -# 5| m5_2(unknown) = AliasedDefinition : -# 5| mu5_3(unknown) = UnmodeledDefinition : -# 6| r6_1(glval) = VariableAddress[#return] : -# 6| r6_2(glval) = VariableAddress[globalInt] : -# 6| r6_3(int *) = CopyValue : r6_2 -# 6| m6_4(int *) = Store : &:r6_1, r6_3 -# 5| r5_4(glval) = VariableAddress[#return] : -# 5| v5_5(void) = ReturnValue : &:r5_4, m6_4 -# 5| v5_6(void) = UnmodeledUse : mu* -# 5| v5_7(void) = AliasedUse : ~m5_2 -# 5| v5_8(void) = ExitFunction : - -ir.cpp: -# 1| void Constants() -# 1| Block 0 -# 1| v1_1(void) = EnterFunction : -# 1| m1_2(unknown) = AliasedDefinition : -# 1| mu1_3(unknown) = UnmodeledDefinition : -# 2| r2_1(glval) = VariableAddress[c_i] : -# 2| r2_2(char) = Constant[1] : -# 2| m2_3(char) = Store : &:r2_1, r2_2 -# 3| r3_1(glval) = VariableAddress[c_c] : -# 3| r3_2(char) = Constant[65] : -# 3| m3_3(char) = Store : &:r3_1, r3_2 -# 5| r5_1(glval) = VariableAddress[sc_i] : -# 5| r5_2(signed char) = Constant[-1] : -# 5| m5_3(signed char) = Store : &:r5_1, r5_2 -# 6| r6_1(glval) = VariableAddress[sc_c] : -# 6| r6_2(signed char) = Constant[65] : -# 6| m6_3(signed char) = Store : &:r6_1, r6_2 -# 8| r8_1(glval) = VariableAddress[uc_i] : -# 8| r8_2(unsigned char) = Constant[5] : -# 8| m8_3(unsigned char) = Store : &:r8_1, r8_2 -# 9| r9_1(glval) = VariableAddress[uc_c] : -# 9| r9_2(unsigned char) = Constant[65] : -# 9| m9_3(unsigned char) = Store : &:r9_1, r9_2 -# 11| r11_1(glval) = VariableAddress[s] : -# 11| r11_2(short) = Constant[5] : -# 11| m11_3(short) = Store : &:r11_1, r11_2 -# 12| r12_1(glval) = VariableAddress[us] : -# 12| r12_2(unsigned short) = Constant[5] : -# 12| m12_3(unsigned short) = Store : &:r12_1, r12_2 -# 14| r14_1(glval) = VariableAddress[i] : -# 14| r14_2(int) = Constant[5] : -# 14| m14_3(int) = Store : &:r14_1, r14_2 -# 15| r15_1(glval) = VariableAddress[ui] : -# 15| r15_2(unsigned int) = Constant[5] : -# 15| m15_3(unsigned int) = Store : &:r15_1, r15_2 -# 17| r17_1(glval) = VariableAddress[l] : -# 17| r17_2(long) = Constant[5] : -# 17| m17_3(long) = Store : &:r17_1, r17_2 -# 18| r18_1(glval) = VariableAddress[ul] : -# 18| r18_2(unsigned long) = Constant[5] : -# 18| m18_3(unsigned long) = Store : &:r18_1, r18_2 -# 20| r20_1(glval) = VariableAddress[ll_i] : -# 20| r20_2(long long) = Constant[5] : -# 20| m20_3(long long) = Store : &:r20_1, r20_2 -# 21| r21_1(glval) = VariableAddress[ll_ll] : -# 21| r21_2(long long) = Constant[5] : -# 21| m21_3(long long) = Store : &:r21_1, r21_2 -# 22| r22_1(glval) = VariableAddress[ull_i] : -# 22| r22_2(unsigned long long) = Constant[5] : -# 22| m22_3(unsigned long long) = Store : &:r22_1, r22_2 -# 23| r23_1(glval) = VariableAddress[ull_ull] : -# 23| r23_2(unsigned long long) = Constant[5] : -# 23| m23_3(unsigned long long) = Store : &:r23_1, r23_2 -# 25| r25_1(glval) = VariableAddress[b_t] : -# 25| r25_2(bool) = Constant[1] : -# 25| m25_3(bool) = Store : &:r25_1, r25_2 -# 26| r26_1(glval) = VariableAddress[b_f] : -# 26| r26_2(bool) = Constant[0] : -# 26| m26_3(bool) = Store : &:r26_1, r26_2 -# 28| r28_1(glval) = VariableAddress[wc_i] : -# 28| r28_2(wchar_t) = Constant[5] : -# 28| m28_3(wchar_t) = Store : &:r28_1, r28_2 -# 29| r29_1(glval) = VariableAddress[wc_c] : -# 29| r29_2(wchar_t) = Constant[65] : -# 29| m29_3(wchar_t) = Store : &:r29_1, r29_2 -# 31| r31_1(glval) = VariableAddress[c16] : -# 31| r31_2(char16_t) = Constant[65] : -# 31| m31_3(char16_t) = Store : &:r31_1, r31_2 -# 32| r32_1(glval) = VariableAddress[c32] : -# 32| r32_2(char32_t) = Constant[65] : -# 32| m32_3(char32_t) = Store : &:r32_1, r32_2 -# 34| r34_1(glval) = VariableAddress[f_i] : -# 34| r34_2(float) = Constant[1.0] : -# 34| m34_3(float) = Store : &:r34_1, r34_2 -# 35| r35_1(glval) = VariableAddress[f_f] : -# 35| r35_2(float) = Constant[1.0] : -# 35| m35_3(float) = Store : &:r35_1, r35_2 -# 36| r36_1(glval) = VariableAddress[f_d] : -# 36| r36_2(float) = Constant[1.0] : -# 36| m36_3(float) = Store : &:r36_1, r36_2 -# 38| r38_1(glval) = VariableAddress[d_i] : -# 38| r38_2(double) = Constant[1.0] : -# 38| m38_3(double) = Store : &:r38_1, r38_2 -# 39| r39_1(glval) = VariableAddress[d_f] : -# 39| r39_2(double) = Constant[1.0] : -# 39| m39_3(double) = Store : &:r39_1, r39_2 -# 40| r40_1(glval) = VariableAddress[d_d] : -# 40| r40_2(double) = Constant[1.0] : -# 40| m40_3(double) = Store : &:r40_1, r40_2 -# 41| v41_1(void) = NoOp : -# 1| v1_4(void) = ReturnVoid : -# 1| v1_5(void) = UnmodeledUse : mu* -# 1| v1_6(void) = AliasedUse : ~m1_2 -# 1| v1_7(void) = ExitFunction : - -# 43| void Foo() -# 43| Block 0 -# 43| v43_1(void) = EnterFunction : -# 43| m43_2(unknown) = AliasedDefinition : -# 43| mu43_3(unknown) = UnmodeledDefinition : -# 44| r44_1(glval) = VariableAddress[x] : -# 44| r44_2(int) = Constant[17] : -# 44| m44_3(int) = Store : &:r44_1, r44_2 -# 45| r45_1(glval) = VariableAddress[y] : -# 45| r45_2(short) = Constant[7] : -# 45| m45_3(short) = Store : &:r45_1, r45_2 -# 46| r46_1(glval) = VariableAddress[x] : -# 46| r46_2(int) = Load : &:r46_1, m44_3 -# 46| r46_3(glval) = VariableAddress[y] : -# 46| r46_4(short) = Load : &:r46_3, m45_3 -# 46| r46_5(int) = Convert : r46_4 -# 46| r46_6(int) = Add : r46_2, r46_5 -# 46| r46_7(short) = Convert : r46_6 -# 46| r46_8(glval) = VariableAddress[y] : -# 46| m46_9(short) = Store : &:r46_8, r46_7 -# 47| r47_1(glval) = VariableAddress[x] : -# 47| r47_2(int) = Load : &:r47_1, m44_3 -# 47| r47_3(glval) = VariableAddress[y] : -# 47| r47_4(short) = Load : &:r47_3, m46_9 -# 47| r47_5(int) = Convert : r47_4 -# 47| r47_6(int) = Mul : r47_2, r47_5 -# 47| r47_7(glval) = VariableAddress[x] : -# 47| m47_8(int) = Store : &:r47_7, r47_6 -# 48| v48_1(void) = NoOp : -# 43| v43_4(void) = ReturnVoid : -# 43| v43_5(void) = UnmodeledUse : mu* -# 43| v43_6(void) = AliasedUse : ~m43_2 -# 43| v43_7(void) = ExitFunction : - -# 50| void IntegerOps(int, int) -# 50| Block 0 -# 50| v50_1(void) = EnterFunction : -# 50| m50_2(unknown) = AliasedDefinition : -# 50| mu50_3(unknown) = UnmodeledDefinition : -# 50| r50_4(glval) = VariableAddress[x] : -# 50| m50_5(int) = InitializeParameter[x] : &:r50_4 -# 50| r50_6(glval) = VariableAddress[y] : -# 50| m50_7(int) = InitializeParameter[y] : &:r50_6 -# 51| r51_1(glval) = VariableAddress[z] : -# 51| m51_2(int) = Uninitialized[z] : &:r51_1 -# 53| r53_1(glval) = VariableAddress[x] : -# 53| r53_2(int) = Load : &:r53_1, m50_5 -# 53| r53_3(glval) = VariableAddress[y] : -# 53| r53_4(int) = Load : &:r53_3, m50_7 -# 53| r53_5(int) = Add : r53_2, r53_4 -# 53| r53_6(glval) = VariableAddress[z] : -# 53| m53_7(int) = Store : &:r53_6, r53_5 -# 54| r54_1(glval) = VariableAddress[x] : -# 54| r54_2(int) = Load : &:r54_1, m50_5 -# 54| r54_3(glval) = VariableAddress[y] : -# 54| r54_4(int) = Load : &:r54_3, m50_7 -# 54| r54_5(int) = Sub : r54_2, r54_4 -# 54| r54_6(glval) = VariableAddress[z] : -# 54| m54_7(int) = Store : &:r54_6, r54_5 -# 55| r55_1(glval) = VariableAddress[x] : -# 55| r55_2(int) = Load : &:r55_1, m50_5 -# 55| r55_3(glval) = VariableAddress[y] : -# 55| r55_4(int) = Load : &:r55_3, m50_7 -# 55| r55_5(int) = Mul : r55_2, r55_4 -# 55| r55_6(glval) = VariableAddress[z] : -# 55| m55_7(int) = Store : &:r55_6, r55_5 -# 56| r56_1(glval) = VariableAddress[x] : -# 56| r56_2(int) = Load : &:r56_1, m50_5 -# 56| r56_3(glval) = VariableAddress[y] : -# 56| r56_4(int) = Load : &:r56_3, m50_7 -# 56| r56_5(int) = Div : r56_2, r56_4 -# 56| r56_6(glval) = VariableAddress[z] : -# 56| m56_7(int) = Store : &:r56_6, r56_5 -# 57| r57_1(glval) = VariableAddress[x] : -# 57| r57_2(int) = Load : &:r57_1, m50_5 -# 57| r57_3(glval) = VariableAddress[y] : -# 57| r57_4(int) = Load : &:r57_3, m50_7 -# 57| r57_5(int) = Rem : r57_2, r57_4 -# 57| r57_6(glval) = VariableAddress[z] : -# 57| m57_7(int) = Store : &:r57_6, r57_5 -# 59| r59_1(glval) = VariableAddress[x] : -# 59| r59_2(int) = Load : &:r59_1, m50_5 -# 59| r59_3(glval) = VariableAddress[y] : -# 59| r59_4(int) = Load : &:r59_3, m50_7 -# 59| r59_5(int) = BitAnd : r59_2, r59_4 -# 59| r59_6(glval) = VariableAddress[z] : -# 59| m59_7(int) = Store : &:r59_6, r59_5 -# 60| r60_1(glval) = VariableAddress[x] : -# 60| r60_2(int) = Load : &:r60_1, m50_5 -# 60| r60_3(glval) = VariableAddress[y] : -# 60| r60_4(int) = Load : &:r60_3, m50_7 -# 60| r60_5(int) = BitOr : r60_2, r60_4 -# 60| r60_6(glval) = VariableAddress[z] : -# 60| m60_7(int) = Store : &:r60_6, r60_5 -# 61| r61_1(glval) = VariableAddress[x] : -# 61| r61_2(int) = Load : &:r61_1, m50_5 -# 61| r61_3(glval) = VariableAddress[y] : -# 61| r61_4(int) = Load : &:r61_3, m50_7 -# 61| r61_5(int) = BitXor : r61_2, r61_4 -# 61| r61_6(glval) = VariableAddress[z] : -# 61| m61_7(int) = Store : &:r61_6, r61_5 -# 63| r63_1(glval) = VariableAddress[x] : -# 63| r63_2(int) = Load : &:r63_1, m50_5 -# 63| r63_3(glval) = VariableAddress[y] : -# 63| r63_4(int) = Load : &:r63_3, m50_7 -# 63| r63_5(int) = ShiftLeft : r63_2, r63_4 -# 63| r63_6(glval) = VariableAddress[z] : -# 63| m63_7(int) = Store : &:r63_6, r63_5 -# 64| r64_1(glval) = VariableAddress[x] : -# 64| r64_2(int) = Load : &:r64_1, m50_5 -# 64| r64_3(glval) = VariableAddress[y] : -# 64| r64_4(int) = Load : &:r64_3, m50_7 -# 64| r64_5(int) = ShiftRight : r64_2, r64_4 -# 64| r64_6(glval) = VariableAddress[z] : -# 64| m64_7(int) = Store : &:r64_6, r64_5 -# 66| r66_1(glval) = VariableAddress[x] : -# 66| r66_2(int) = Load : &:r66_1, m50_5 -# 66| r66_3(glval) = VariableAddress[z] : -# 66| m66_4(int) = Store : &:r66_3, r66_2 -# 68| r68_1(glval) = VariableAddress[x] : -# 68| r68_2(int) = Load : &:r68_1, m50_5 -# 68| r68_3(glval) = VariableAddress[z] : -# 68| r68_4(int) = Load : &:r68_3, m66_4 -# 68| r68_5(int) = Add : r68_4, r68_2 -# 68| m68_6(int) = Store : &:r68_3, r68_5 -# 69| r69_1(glval) = VariableAddress[x] : -# 69| r69_2(int) = Load : &:r69_1, m50_5 -# 69| r69_3(glval) = VariableAddress[z] : -# 69| r69_4(int) = Load : &:r69_3, m68_6 -# 69| r69_5(int) = Sub : r69_4, r69_2 -# 69| m69_6(int) = Store : &:r69_3, r69_5 -# 70| r70_1(glval) = VariableAddress[x] : -# 70| r70_2(int) = Load : &:r70_1, m50_5 -# 70| r70_3(glval) = VariableAddress[z] : -# 70| r70_4(int) = Load : &:r70_3, m69_6 -# 70| r70_5(int) = Mul : r70_4, r70_2 -# 70| m70_6(int) = Store : &:r70_3, r70_5 -# 71| r71_1(glval) = VariableAddress[x] : -# 71| r71_2(int) = Load : &:r71_1, m50_5 -# 71| r71_3(glval) = VariableAddress[z] : -# 71| r71_4(int) = Load : &:r71_3, m70_6 -# 71| r71_5(int) = Div : r71_4, r71_2 -# 71| m71_6(int) = Store : &:r71_3, r71_5 -# 72| r72_1(glval) = VariableAddress[x] : -# 72| r72_2(int) = Load : &:r72_1, m50_5 -# 72| r72_3(glval) = VariableAddress[z] : -# 72| r72_4(int) = Load : &:r72_3, m71_6 -# 72| r72_5(int) = Rem : r72_4, r72_2 -# 72| m72_6(int) = Store : &:r72_3, r72_5 -# 74| r74_1(glval) = VariableAddress[x] : -# 74| r74_2(int) = Load : &:r74_1, m50_5 -# 74| r74_3(glval) = VariableAddress[z] : -# 74| r74_4(int) = Load : &:r74_3, m72_6 -# 74| r74_5(int) = BitAnd : r74_4, r74_2 -# 74| m74_6(int) = Store : &:r74_3, r74_5 -# 75| r75_1(glval) = VariableAddress[x] : -# 75| r75_2(int) = Load : &:r75_1, m50_5 -# 75| r75_3(glval) = VariableAddress[z] : -# 75| r75_4(int) = Load : &:r75_3, m74_6 -# 75| r75_5(int) = BitOr : r75_4, r75_2 -# 75| m75_6(int) = Store : &:r75_3, r75_5 -# 76| r76_1(glval) = VariableAddress[x] : -# 76| r76_2(int) = Load : &:r76_1, m50_5 -# 76| r76_3(glval) = VariableAddress[z] : -# 76| r76_4(int) = Load : &:r76_3, m75_6 -# 76| r76_5(int) = BitXor : r76_4, r76_2 -# 76| m76_6(int) = Store : &:r76_3, r76_5 -# 78| r78_1(glval) = VariableAddress[x] : -# 78| r78_2(int) = Load : &:r78_1, m50_5 -# 78| r78_3(glval) = VariableAddress[z] : -# 78| r78_4(int) = Load : &:r78_3, m76_6 -# 78| r78_5(int) = ShiftLeft : r78_4, r78_2 -# 78| m78_6(int) = Store : &:r78_3, r78_5 -# 79| r79_1(glval) = VariableAddress[x] : -# 79| r79_2(int) = Load : &:r79_1, m50_5 -# 79| r79_3(glval) = VariableAddress[z] : -# 79| r79_4(int) = Load : &:r79_3, m78_6 -# 79| r79_5(int) = ShiftRight : r79_4, r79_2 -# 79| m79_6(int) = Store : &:r79_3, r79_5 -# 81| r81_1(glval) = VariableAddress[x] : -# 81| r81_2(int) = Load : &:r81_1, m50_5 -# 81| r81_3(int) = CopyValue : r81_2 -# 81| r81_4(glval) = VariableAddress[z] : -# 81| m81_5(int) = Store : &:r81_4, r81_3 -# 82| r82_1(glval) = VariableAddress[x] : -# 82| r82_2(int) = Load : &:r82_1, m50_5 -# 82| r82_3(int) = Negate : r82_2 -# 82| r82_4(glval) = VariableAddress[z] : -# 82| m82_5(int) = Store : &:r82_4, r82_3 -# 83| r83_1(glval) = VariableAddress[x] : -# 83| r83_2(int) = Load : &:r83_1, m50_5 -# 83| r83_3(int) = BitComplement : r83_2 -# 83| r83_4(glval) = VariableAddress[z] : -# 83| m83_5(int) = Store : &:r83_4, r83_3 -# 84| r84_1(glval) = VariableAddress[x] : -# 84| r84_2(int) = Load : &:r84_1, m50_5 -# 84| r84_3(int) = Constant[0] : -# 84| r84_4(bool) = CompareNE : r84_2, r84_3 -# 84| r84_5(bool) = LogicalNot : r84_4 -# 84| r84_6(int) = Convert : r84_5 -# 84| r84_7(glval) = VariableAddress[z] : -# 84| m84_8(int) = Store : &:r84_7, r84_6 -# 85| v85_1(void) = NoOp : -# 50| v50_8(void) = ReturnVoid : -# 50| v50_9(void) = UnmodeledUse : mu* -# 50| v50_10(void) = AliasedUse : ~m50_2 -# 50| v50_11(void) = ExitFunction : - -# 87| void IntegerCompare(int, int) -# 87| Block 0 -# 87| v87_1(void) = EnterFunction : -# 87| m87_2(unknown) = AliasedDefinition : -# 87| mu87_3(unknown) = UnmodeledDefinition : -# 87| r87_4(glval) = VariableAddress[x] : -# 87| m87_5(int) = InitializeParameter[x] : &:r87_4 -# 87| r87_6(glval) = VariableAddress[y] : -# 87| m87_7(int) = InitializeParameter[y] : &:r87_6 -# 88| r88_1(glval) = VariableAddress[b] : -# 88| m88_2(bool) = Uninitialized[b] : &:r88_1 -# 90| r90_1(glval) = VariableAddress[x] : -# 90| r90_2(int) = Load : &:r90_1, m87_5 -# 90| r90_3(glval) = VariableAddress[y] : -# 90| r90_4(int) = Load : &:r90_3, m87_7 -# 90| r90_5(bool) = CompareEQ : r90_2, r90_4 -# 90| r90_6(glval) = VariableAddress[b] : -# 90| m90_7(bool) = Store : &:r90_6, r90_5 -# 91| r91_1(glval) = VariableAddress[x] : -# 91| r91_2(int) = Load : &:r91_1, m87_5 -# 91| r91_3(glval) = VariableAddress[y] : -# 91| r91_4(int) = Load : &:r91_3, m87_7 -# 91| r91_5(bool) = CompareNE : r91_2, r91_4 -# 91| r91_6(glval) = VariableAddress[b] : -# 91| m91_7(bool) = Store : &:r91_6, r91_5 -# 92| r92_1(glval) = VariableAddress[x] : -# 92| r92_2(int) = Load : &:r92_1, m87_5 -# 92| r92_3(glval) = VariableAddress[y] : -# 92| r92_4(int) = Load : &:r92_3, m87_7 -# 92| r92_5(bool) = CompareLT : r92_2, r92_4 -# 92| r92_6(glval) = VariableAddress[b] : -# 92| m92_7(bool) = Store : &:r92_6, r92_5 -# 93| r93_1(glval) = VariableAddress[x] : -# 93| r93_2(int) = Load : &:r93_1, m87_5 -# 93| r93_3(glval) = VariableAddress[y] : -# 93| r93_4(int) = Load : &:r93_3, m87_7 -# 93| r93_5(bool) = CompareGT : r93_2, r93_4 -# 93| r93_6(glval) = VariableAddress[b] : -# 93| m93_7(bool) = Store : &:r93_6, r93_5 -# 94| r94_1(glval) = VariableAddress[x] : -# 94| r94_2(int) = Load : &:r94_1, m87_5 -# 94| r94_3(glval) = VariableAddress[y] : -# 94| r94_4(int) = Load : &:r94_3, m87_7 -# 94| r94_5(bool) = CompareLE : r94_2, r94_4 -# 94| r94_6(glval) = VariableAddress[b] : -# 94| m94_7(bool) = Store : &:r94_6, r94_5 -# 95| r95_1(glval) = VariableAddress[x] : -# 95| r95_2(int) = Load : &:r95_1, m87_5 -# 95| r95_3(glval) = VariableAddress[y] : -# 95| r95_4(int) = Load : &:r95_3, m87_7 -# 95| r95_5(bool) = CompareGE : r95_2, r95_4 -# 95| r95_6(glval) = VariableAddress[b] : -# 95| m95_7(bool) = Store : &:r95_6, r95_5 -# 96| v96_1(void) = NoOp : -# 87| v87_8(void) = ReturnVoid : -# 87| v87_9(void) = UnmodeledUse : mu* -# 87| v87_10(void) = AliasedUse : ~m87_2 -# 87| v87_11(void) = ExitFunction : - -# 98| void IntegerCrement(int) -# 98| Block 0 -# 98| v98_1(void) = EnterFunction : -# 98| m98_2(unknown) = AliasedDefinition : -# 98| mu98_3(unknown) = UnmodeledDefinition : -# 98| r98_4(glval) = VariableAddress[x] : -# 98| m98_5(int) = InitializeParameter[x] : &:r98_4 -# 99| r99_1(glval) = VariableAddress[y] : -# 99| m99_2(int) = Uninitialized[y] : &:r99_1 -# 101| r101_1(glval) = VariableAddress[x] : -# 101| r101_2(int) = Load : &:r101_1, m98_5 -# 101| r101_3(int) = Constant[1] : -# 101| r101_4(int) = Add : r101_2, r101_3 -# 101| m101_5(int) = Store : &:r101_1, r101_4 -# 101| r101_6(glval) = VariableAddress[y] : -# 101| m101_7(int) = Store : &:r101_6, r101_4 -# 102| r102_1(glval) = VariableAddress[x] : -# 102| r102_2(int) = Load : &:r102_1, m101_5 -# 102| r102_3(int) = Constant[1] : -# 102| r102_4(int) = Sub : r102_2, r102_3 -# 102| m102_5(int) = Store : &:r102_1, r102_4 -# 102| r102_6(glval) = VariableAddress[y] : -# 102| m102_7(int) = Store : &:r102_6, r102_4 -# 103| r103_1(glval) = VariableAddress[x] : -# 103| r103_2(int) = Load : &:r103_1, m102_5 -# 103| r103_3(int) = Constant[1] : -# 103| r103_4(int) = Add : r103_2, r103_3 -# 103| m103_5(int) = Store : &:r103_1, r103_4 -# 103| r103_6(glval) = VariableAddress[y] : -# 103| m103_7(int) = Store : &:r103_6, r103_2 -# 104| r104_1(glval) = VariableAddress[x] : -# 104| r104_2(int) = Load : &:r104_1, m103_5 -# 104| r104_3(int) = Constant[1] : -# 104| r104_4(int) = Sub : r104_2, r104_3 -# 104| m104_5(int) = Store : &:r104_1, r104_4 -# 104| r104_6(glval) = VariableAddress[y] : -# 104| m104_7(int) = Store : &:r104_6, r104_2 -# 105| v105_1(void) = NoOp : -# 98| v98_6(void) = ReturnVoid : -# 98| v98_7(void) = UnmodeledUse : mu* -# 98| v98_8(void) = AliasedUse : ~m98_2 -# 98| v98_9(void) = ExitFunction : - -# 107| void IntegerCrement_LValue(int) -# 107| Block 0 -# 107| v107_1(void) = EnterFunction : -# 107| m107_2(unknown) = AliasedDefinition : -# 107| mu107_3(unknown) = UnmodeledDefinition : -# 107| r107_4(glval) = VariableAddress[x] : -# 107| m107_5(int) = InitializeParameter[x] : &:r107_4 -# 108| r108_1(glval) = VariableAddress[p] : -# 108| m108_2(int *) = Uninitialized[p] : &:r108_1 -# 110| r110_1(glval) = VariableAddress[x] : -# 110| r110_2(int) = Load : &:r110_1, m107_5 -# 110| r110_3(int) = Constant[1] : -# 110| r110_4(int) = Add : r110_2, r110_3 -# 110| m110_5(int) = Store : &:r110_1, r110_4 -# 110| r110_6(glval) = CopyValue : r110_1 -# 110| r110_7(int *) = CopyValue : r110_6 -# 110| r110_8(glval) = VariableAddress[p] : -# 110| m110_9(int *) = Store : &:r110_8, r110_7 -# 111| r111_1(glval) = VariableAddress[x] : -# 111| r111_2(int) = Load : &:r111_1, m110_5 -# 111| r111_3(int) = Constant[1] : -# 111| r111_4(int) = Sub : r111_2, r111_3 -# 111| m111_5(int) = Store : &:r111_1, r111_4 -# 111| r111_6(glval) = CopyValue : r111_1 -# 111| r111_7(int *) = CopyValue : r111_6 -# 111| r111_8(glval) = VariableAddress[p] : -# 111| m111_9(int *) = Store : &:r111_8, r111_7 -# 112| v112_1(void) = NoOp : -# 107| v107_6(void) = ReturnVoid : -# 107| v107_7(void) = UnmodeledUse : mu* -# 107| v107_8(void) = AliasedUse : ~m107_2 -# 107| v107_9(void) = ExitFunction : - -# 114| void FloatOps(double, double) -# 114| Block 0 -# 114| v114_1(void) = EnterFunction : -# 114| m114_2(unknown) = AliasedDefinition : -# 114| mu114_3(unknown) = UnmodeledDefinition : -# 114| r114_4(glval) = VariableAddress[x] : -# 114| m114_5(double) = InitializeParameter[x] : &:r114_4 -# 114| r114_6(glval) = VariableAddress[y] : -# 114| m114_7(double) = InitializeParameter[y] : &:r114_6 -# 115| r115_1(glval) = VariableAddress[z] : -# 115| m115_2(double) = Uninitialized[z] : &:r115_1 -# 117| r117_1(glval) = VariableAddress[x] : -# 117| r117_2(double) = Load : &:r117_1, m114_5 -# 117| r117_3(glval) = VariableAddress[y] : -# 117| r117_4(double) = Load : &:r117_3, m114_7 -# 117| r117_5(double) = Add : r117_2, r117_4 -# 117| r117_6(glval) = VariableAddress[z] : -# 117| m117_7(double) = Store : &:r117_6, r117_5 -# 118| r118_1(glval) = VariableAddress[x] : -# 118| r118_2(double) = Load : &:r118_1, m114_5 -# 118| r118_3(glval) = VariableAddress[y] : -# 118| r118_4(double) = Load : &:r118_3, m114_7 -# 118| r118_5(double) = Sub : r118_2, r118_4 -# 118| r118_6(glval) = VariableAddress[z] : -# 118| m118_7(double) = Store : &:r118_6, r118_5 -# 119| r119_1(glval) = VariableAddress[x] : -# 119| r119_2(double) = Load : &:r119_1, m114_5 -# 119| r119_3(glval) = VariableAddress[y] : -# 119| r119_4(double) = Load : &:r119_3, m114_7 -# 119| r119_5(double) = Mul : r119_2, r119_4 -# 119| r119_6(glval) = VariableAddress[z] : -# 119| m119_7(double) = Store : &:r119_6, r119_5 -# 120| r120_1(glval) = VariableAddress[x] : -# 120| r120_2(double) = Load : &:r120_1, m114_5 -# 120| r120_3(glval) = VariableAddress[y] : -# 120| r120_4(double) = Load : &:r120_3, m114_7 -# 120| r120_5(double) = Div : r120_2, r120_4 -# 120| r120_6(glval) = VariableAddress[z] : -# 120| m120_7(double) = Store : &:r120_6, r120_5 -# 122| r122_1(glval) = VariableAddress[x] : -# 122| r122_2(double) = Load : &:r122_1, m114_5 -# 122| r122_3(glval) = VariableAddress[z] : -# 122| m122_4(double) = Store : &:r122_3, r122_2 -# 124| r124_1(glval) = VariableAddress[x] : -# 124| r124_2(double) = Load : &:r124_1, m114_5 -# 124| r124_3(glval) = VariableAddress[z] : -# 124| r124_4(double) = Load : &:r124_3, m122_4 -# 124| r124_5(double) = Add : r124_4, r124_2 -# 124| m124_6(double) = Store : &:r124_3, r124_5 -# 125| r125_1(glval) = VariableAddress[x] : -# 125| r125_2(double) = Load : &:r125_1, m114_5 -# 125| r125_3(glval) = VariableAddress[z] : -# 125| r125_4(double) = Load : &:r125_3, m124_6 -# 125| r125_5(double) = Sub : r125_4, r125_2 -# 125| m125_6(double) = Store : &:r125_3, r125_5 -# 126| r126_1(glval) = VariableAddress[x] : -# 126| r126_2(double) = Load : &:r126_1, m114_5 -# 126| r126_3(glval) = VariableAddress[z] : -# 126| r126_4(double) = Load : &:r126_3, m125_6 -# 126| r126_5(double) = Mul : r126_4, r126_2 -# 126| m126_6(double) = Store : &:r126_3, r126_5 -# 127| r127_1(glval) = VariableAddress[x] : -# 127| r127_2(double) = Load : &:r127_1, m114_5 -# 127| r127_3(glval) = VariableAddress[z] : -# 127| r127_4(double) = Load : &:r127_3, m126_6 -# 127| r127_5(double) = Div : r127_4, r127_2 -# 127| m127_6(double) = Store : &:r127_3, r127_5 -# 129| r129_1(glval) = VariableAddress[x] : -# 129| r129_2(double) = Load : &:r129_1, m114_5 -# 129| r129_3(double) = CopyValue : r129_2 -# 129| r129_4(glval) = VariableAddress[z] : -# 129| m129_5(double) = Store : &:r129_4, r129_3 -# 130| r130_1(glval) = VariableAddress[x] : -# 130| r130_2(double) = Load : &:r130_1, m114_5 -# 130| r130_3(double) = Negate : r130_2 -# 130| r130_4(glval) = VariableAddress[z] : -# 130| m130_5(double) = Store : &:r130_4, r130_3 -# 131| v131_1(void) = NoOp : -# 114| v114_8(void) = ReturnVoid : -# 114| v114_9(void) = UnmodeledUse : mu* -# 114| v114_10(void) = AliasedUse : ~m114_2 -# 114| v114_11(void) = ExitFunction : - -# 133| void FloatCompare(double, double) -# 133| Block 0 -# 133| v133_1(void) = EnterFunction : -# 133| m133_2(unknown) = AliasedDefinition : -# 133| mu133_3(unknown) = UnmodeledDefinition : -# 133| r133_4(glval) = VariableAddress[x] : -# 133| m133_5(double) = InitializeParameter[x] : &:r133_4 -# 133| r133_6(glval) = VariableAddress[y] : -# 133| m133_7(double) = InitializeParameter[y] : &:r133_6 -# 134| r134_1(glval) = VariableAddress[b] : -# 134| m134_2(bool) = Uninitialized[b] : &:r134_1 -# 136| r136_1(glval) = VariableAddress[x] : -# 136| r136_2(double) = Load : &:r136_1, m133_5 -# 136| r136_3(glval) = VariableAddress[y] : -# 136| r136_4(double) = Load : &:r136_3, m133_7 -# 136| r136_5(bool) = CompareEQ : r136_2, r136_4 -# 136| r136_6(glval) = VariableAddress[b] : -# 136| m136_7(bool) = Store : &:r136_6, r136_5 -# 137| r137_1(glval) = VariableAddress[x] : -# 137| r137_2(double) = Load : &:r137_1, m133_5 -# 137| r137_3(glval) = VariableAddress[y] : -# 137| r137_4(double) = Load : &:r137_3, m133_7 -# 137| r137_5(bool) = CompareNE : r137_2, r137_4 -# 137| r137_6(glval) = VariableAddress[b] : -# 137| m137_7(bool) = Store : &:r137_6, r137_5 -# 138| r138_1(glval) = VariableAddress[x] : -# 138| r138_2(double) = Load : &:r138_1, m133_5 -# 138| r138_3(glval) = VariableAddress[y] : -# 138| r138_4(double) = Load : &:r138_3, m133_7 -# 138| r138_5(bool) = CompareLT : r138_2, r138_4 -# 138| r138_6(glval) = VariableAddress[b] : -# 138| m138_7(bool) = Store : &:r138_6, r138_5 -# 139| r139_1(glval) = VariableAddress[x] : -# 139| r139_2(double) = Load : &:r139_1, m133_5 -# 139| r139_3(glval) = VariableAddress[y] : -# 139| r139_4(double) = Load : &:r139_3, m133_7 -# 139| r139_5(bool) = CompareGT : r139_2, r139_4 -# 139| r139_6(glval) = VariableAddress[b] : -# 139| m139_7(bool) = Store : &:r139_6, r139_5 -# 140| r140_1(glval) = VariableAddress[x] : -# 140| r140_2(double) = Load : &:r140_1, m133_5 -# 140| r140_3(glval) = VariableAddress[y] : -# 140| r140_4(double) = Load : &:r140_3, m133_7 -# 140| r140_5(bool) = CompareLE : r140_2, r140_4 -# 140| r140_6(glval) = VariableAddress[b] : -# 140| m140_7(bool) = Store : &:r140_6, r140_5 -# 141| r141_1(glval) = VariableAddress[x] : -# 141| r141_2(double) = Load : &:r141_1, m133_5 -# 141| r141_3(glval) = VariableAddress[y] : -# 141| r141_4(double) = Load : &:r141_3, m133_7 -# 141| r141_5(bool) = CompareGE : r141_2, r141_4 -# 141| r141_6(glval) = VariableAddress[b] : -# 141| m141_7(bool) = Store : &:r141_6, r141_5 -# 142| v142_1(void) = NoOp : -# 133| v133_8(void) = ReturnVoid : -# 133| v133_9(void) = UnmodeledUse : mu* -# 133| v133_10(void) = AliasedUse : ~m133_2 -# 133| v133_11(void) = ExitFunction : - -# 144| void FloatCrement(float) -# 144| Block 0 -# 144| v144_1(void) = EnterFunction : -# 144| m144_2(unknown) = AliasedDefinition : -# 144| mu144_3(unknown) = UnmodeledDefinition : -# 144| r144_4(glval) = VariableAddress[x] : -# 144| m144_5(float) = InitializeParameter[x] : &:r144_4 -# 145| r145_1(glval) = VariableAddress[y] : -# 145| m145_2(float) = Uninitialized[y] : &:r145_1 -# 147| r147_1(glval) = VariableAddress[x] : -# 147| r147_2(float) = Load : &:r147_1, m144_5 -# 147| r147_3(float) = Constant[1.0] : -# 147| r147_4(float) = Add : r147_2, r147_3 -# 147| m147_5(float) = Store : &:r147_1, r147_4 -# 147| r147_6(glval) = VariableAddress[y] : -# 147| m147_7(float) = Store : &:r147_6, r147_4 -# 148| r148_1(glval) = VariableAddress[x] : -# 148| r148_2(float) = Load : &:r148_1, m147_5 -# 148| r148_3(float) = Constant[1.0] : -# 148| r148_4(float) = Sub : r148_2, r148_3 -# 148| m148_5(float) = Store : &:r148_1, r148_4 -# 148| r148_6(glval) = VariableAddress[y] : -# 148| m148_7(float) = Store : &:r148_6, r148_4 -# 149| r149_1(glval) = VariableAddress[x] : -# 149| r149_2(float) = Load : &:r149_1, m148_5 -# 149| r149_3(float) = Constant[1.0] : -# 149| r149_4(float) = Add : r149_2, r149_3 -# 149| m149_5(float) = Store : &:r149_1, r149_4 -# 149| r149_6(glval) = VariableAddress[y] : -# 149| m149_7(float) = Store : &:r149_6, r149_2 -# 150| r150_1(glval) = VariableAddress[x] : -# 150| r150_2(float) = Load : &:r150_1, m149_5 -# 150| r150_3(float) = Constant[1.0] : -# 150| r150_4(float) = Sub : r150_2, r150_3 -# 150| m150_5(float) = Store : &:r150_1, r150_4 -# 150| r150_6(glval) = VariableAddress[y] : -# 150| m150_7(float) = Store : &:r150_6, r150_2 -# 151| v151_1(void) = NoOp : -# 144| v144_6(void) = ReturnVoid : -# 144| v144_7(void) = UnmodeledUse : mu* -# 144| v144_8(void) = AliasedUse : ~m144_2 -# 144| v144_9(void) = ExitFunction : - -# 153| void PointerOps(int*, int) -# 153| Block 0 -# 153| v153_1(void) = EnterFunction : -# 153| m153_2(unknown) = AliasedDefinition : -# 153| mu153_3(unknown) = UnmodeledDefinition : -# 153| r153_4(glval) = VariableAddress[p] : -# 153| m153_5(int *) = InitializeParameter[p] : &:r153_4 -# 153| r153_6(int *) = Load : &:r153_4, m153_5 -# 153| m153_7(unknown) = InitializeIndirection[p] : &:r153_6 -# 153| m153_8(unknown) = Chi : total:m153_2, partial:m153_7 -# 153| r153_9(glval) = VariableAddress[i] : -# 153| m153_10(int) = InitializeParameter[i] : &:r153_9 -# 154| r154_1(glval) = VariableAddress[q] : -# 154| m154_2(int *) = Uninitialized[q] : &:r154_1 -# 155| r155_1(glval) = VariableAddress[b] : -# 155| m155_2(bool) = Uninitialized[b] : &:r155_1 -# 157| r157_1(glval) = VariableAddress[p] : -# 157| r157_2(int *) = Load : &:r157_1, m153_5 -# 157| r157_3(glval) = VariableAddress[i] : -# 157| r157_4(int) = Load : &:r157_3, m153_10 -# 157| r157_5(int *) = PointerAdd[4] : r157_2, r157_4 -# 157| r157_6(glval) = VariableAddress[q] : -# 157| m157_7(int *) = Store : &:r157_6, r157_5 -# 158| r158_1(glval) = VariableAddress[i] : -# 158| r158_2(int) = Load : &:r158_1, m153_10 -# 158| r158_3(glval) = VariableAddress[p] : -# 158| r158_4(int *) = Load : &:r158_3, m153_5 -# 158| r158_5(int *) = PointerAdd[4] : r158_4, r158_2 -# 158| r158_6(glval) = VariableAddress[q] : -# 158| m158_7(int *) = Store : &:r158_6, r158_5 -# 159| r159_1(glval) = VariableAddress[p] : -# 159| r159_2(int *) = Load : &:r159_1, m153_5 -# 159| r159_3(glval) = VariableAddress[i] : -# 159| r159_4(int) = Load : &:r159_3, m153_10 -# 159| r159_5(int *) = PointerSub[4] : r159_2, r159_4 -# 159| r159_6(glval) = VariableAddress[q] : -# 159| m159_7(int *) = Store : &:r159_6, r159_5 -# 160| r160_1(glval) = VariableAddress[p] : -# 160| r160_2(int *) = Load : &:r160_1, m153_5 -# 160| r160_3(glval) = VariableAddress[q] : -# 160| r160_4(int *) = Load : &:r160_3, m159_7 -# 160| r160_5(long) = PointerDiff[4] : r160_2, r160_4 -# 160| r160_6(int) = Convert : r160_5 -# 160| r160_7(glval) = VariableAddress[i] : -# 160| m160_8(int) = Store : &:r160_7, r160_6 -# 162| r162_1(glval) = VariableAddress[p] : -# 162| r162_2(int *) = Load : &:r162_1, m153_5 -# 162| r162_3(glval) = VariableAddress[q] : -# 162| m162_4(int *) = Store : &:r162_3, r162_2 -# 164| r164_1(glval) = VariableAddress[i] : -# 164| r164_2(int) = Load : &:r164_1, m160_8 -# 164| r164_3(glval) = VariableAddress[q] : -# 164| r164_4(int *) = Load : &:r164_3, m162_4 -# 164| r164_5(int *) = PointerAdd[4] : r164_4, r164_2 -# 164| m164_6(int *) = Store : &:r164_3, r164_5 -# 165| r165_1(glval) = VariableAddress[i] : -# 165| r165_2(int) = Load : &:r165_1, m160_8 -# 165| r165_3(glval) = VariableAddress[q] : -# 165| r165_4(int *) = Load : &:r165_3, m164_6 -# 165| r165_5(int *) = PointerSub[4] : r165_4, r165_2 -# 165| m165_6(int *) = Store : &:r165_3, r165_5 -# 167| r167_1(glval) = VariableAddress[p] : -# 167| r167_2(int *) = Load : &:r167_1, m153_5 -# 167| r167_3(int *) = Constant[0] : -# 167| r167_4(bool) = CompareNE : r167_2, r167_3 -# 167| r167_5(glval) = VariableAddress[b] : -# 167| m167_6(bool) = Store : &:r167_5, r167_4 -# 168| r168_1(glval) = VariableAddress[p] : -# 168| r168_2(int *) = Load : &:r168_1, m153_5 -# 168| r168_3(int *) = Constant[0] : -# 168| r168_4(bool) = CompareNE : r168_2, r168_3 -# 168| r168_5(bool) = LogicalNot : r168_4 -# 168| r168_6(glval) = VariableAddress[b] : -# 168| m168_7(bool) = Store : &:r168_6, r168_5 -# 169| v169_1(void) = NoOp : -# 153| v153_11(void) = ReturnIndirection : &:r153_6, ~m153_8 -# 153| v153_12(void) = ReturnVoid : -# 153| v153_13(void) = UnmodeledUse : mu* -# 153| v153_14(void) = AliasedUse : ~m153_8 -# 153| v153_15(void) = ExitFunction : - -# 171| void ArrayAccess(int*, int) -# 171| Block 0 -# 171| v171_1(void) = EnterFunction : -# 171| m171_2(unknown) = AliasedDefinition : -# 171| mu171_3(unknown) = UnmodeledDefinition : -# 171| r171_4(glval) = VariableAddress[p] : -# 171| m171_5(int *) = InitializeParameter[p] : &:r171_4 -# 171| r171_6(int *) = Load : &:r171_4, m171_5 -# 171| m171_7(unknown) = InitializeIndirection[p] : &:r171_6 -# 171| m171_8(unknown) = Chi : total:m171_2, partial:m171_7 -# 171| r171_9(glval) = VariableAddress[i] : -# 171| m171_10(int) = InitializeParameter[i] : &:r171_9 -# 172| r172_1(glval) = VariableAddress[x] : -# 172| m172_2(int) = Uninitialized[x] : &:r172_1 -# 174| r174_1(glval) = VariableAddress[p] : -# 174| r174_2(int *) = Load : &:r174_1, m171_5 -# 174| r174_3(glval) = VariableAddress[i] : -# 174| r174_4(int) = Load : &:r174_3, m171_10 -# 174| r174_5(glval) = PointerAdd[4] : r174_2, r174_4 -# 174| r174_6(int) = Load : &:r174_5, ~m171_8 -# 174| r174_7(glval) = VariableAddress[x] : -# 174| m174_8(int) = Store : &:r174_7, r174_6 -# 175| r175_1(glval) = VariableAddress[p] : -# 175| r175_2(int *) = Load : &:r175_1, m171_5 -# 175| r175_3(glval) = VariableAddress[i] : -# 175| r175_4(int) = Load : &:r175_3, m171_10 -# 175| r175_5(glval) = PointerAdd[4] : r175_2, r175_4 -# 175| r175_6(int) = Load : &:r175_5, ~m171_8 -# 175| r175_7(glval) = VariableAddress[x] : -# 175| m175_8(int) = Store : &:r175_7, r175_6 -# 177| r177_1(glval) = VariableAddress[x] : -# 177| r177_2(int) = Load : &:r177_1, m175_8 -# 177| r177_3(glval) = VariableAddress[p] : -# 177| r177_4(int *) = Load : &:r177_3, m171_5 -# 177| r177_5(glval) = VariableAddress[i] : -# 177| r177_6(int) = Load : &:r177_5, m171_10 -# 177| r177_7(glval) = PointerAdd[4] : r177_4, r177_6 -# 177| m177_8(int) = Store : &:r177_7, r177_2 -# 177| m177_9(unknown) = Chi : total:m171_8, partial:m177_8 -# 178| r178_1(glval) = VariableAddress[x] : -# 178| r178_2(int) = Load : &:r178_1, m175_8 -# 178| r178_3(glval) = VariableAddress[p] : -# 178| r178_4(int *) = Load : &:r178_3, m171_5 -# 178| r178_5(glval) = VariableAddress[i] : -# 178| r178_6(int) = Load : &:r178_5, m171_10 -# 178| r178_7(glval) = PointerAdd[4] : r178_4, r178_6 -# 178| m178_8(int) = Store : &:r178_7, r178_2 -# 178| m178_9(unknown) = Chi : total:m177_9, partial:m178_8 -# 180| r180_1(glval) = VariableAddress[a] : -# 180| m180_2(int[10]) = Uninitialized[a] : &:r180_1 -# 181| r181_1(glval) = VariableAddress[a] : -# 181| r181_2(int *) = Convert : r181_1 -# 181| r181_3(glval) = VariableAddress[i] : -# 181| r181_4(int) = Load : &:r181_3, m171_10 -# 181| r181_5(glval) = PointerAdd[4] : r181_2, r181_4 -# 181| r181_6(int) = Load : &:r181_5, ~m180_2 -# 181| r181_7(glval) = VariableAddress[x] : -# 181| m181_8(int) = Store : &:r181_7, r181_6 -# 182| r182_1(glval) = VariableAddress[a] : -# 182| r182_2(int *) = Convert : r182_1 -# 182| r182_3(glval) = VariableAddress[i] : -# 182| r182_4(int) = Load : &:r182_3, m171_10 -# 182| r182_5(glval) = PointerAdd[4] : r182_2, r182_4 -# 182| r182_6(int) = Load : &:r182_5, ~m180_2 -# 182| r182_7(glval) = VariableAddress[x] : -# 182| m182_8(int) = Store : &:r182_7, r182_6 -# 183| r183_1(glval) = VariableAddress[x] : -# 183| r183_2(int) = Load : &:r183_1, m182_8 -# 183| r183_3(glval) = VariableAddress[a] : -# 183| r183_4(int *) = Convert : r183_3 -# 183| r183_5(glval) = VariableAddress[i] : -# 183| r183_6(int) = Load : &:r183_5, m171_10 -# 183| r183_7(glval) = PointerAdd[4] : r183_4, r183_6 -# 183| m183_8(int) = Store : &:r183_7, r183_2 -# 183| m183_9(int[10]) = Chi : total:m180_2, partial:m183_8 -# 184| r184_1(glval) = VariableAddress[x] : -# 184| r184_2(int) = Load : &:r184_1, m182_8 -# 184| r184_3(glval) = VariableAddress[a] : -# 184| r184_4(int *) = Convert : r184_3 -# 184| r184_5(glval) = VariableAddress[i] : -# 184| r184_6(int) = Load : &:r184_5, m171_10 -# 184| r184_7(glval) = PointerAdd[4] : r184_4, r184_6 -# 184| m184_8(int) = Store : &:r184_7, r184_2 -# 184| m184_9(int[10]) = Chi : total:m183_9, partial:m184_8 -# 185| v185_1(void) = NoOp : -# 171| v171_11(void) = ReturnIndirection : &:r171_6, ~m178_9 -# 171| v171_12(void) = ReturnVoid : -# 171| v171_13(void) = UnmodeledUse : mu* -# 171| v171_14(void) = AliasedUse : ~m178_9 -# 171| v171_15(void) = ExitFunction : - -# 187| void StringLiteral(int) -# 187| Block 0 -# 187| v187_1(void) = EnterFunction : -# 187| m187_2(unknown) = AliasedDefinition : -# 187| mu187_3(unknown) = UnmodeledDefinition : -# 187| r187_4(glval) = VariableAddress[i] : -# 187| m187_5(int) = InitializeParameter[i] : &:r187_4 -# 188| r188_1(glval) = VariableAddress[c] : -# 188| r188_2(glval) = StringConstant["Foo"] : -# 188| r188_3(char *) = Convert : r188_2 -# 188| r188_4(glval) = VariableAddress[i] : -# 188| r188_5(int) = Load : &:r188_4, m187_5 -# 188| r188_6(glval) = PointerAdd[1] : r188_3, r188_5 -# 188| r188_7(char) = Load : &:r188_6, ~m187_2 -# 188| m188_8(char) = Store : &:r188_1, r188_7 -# 189| r189_1(glval) = VariableAddress[pwc] : -# 189| r189_2(glval) = StringConstant[L"Bar"] : -# 189| r189_3(wchar_t *) = Convert : r189_2 -# 189| r189_4(wchar_t *) = Convert : r189_3 -# 189| m189_5(wchar_t *) = Store : &:r189_1, r189_4 -# 190| r190_1(glval) = VariableAddress[wc] : -# 190| r190_2(glval) = VariableAddress[pwc] : -# 190| r190_3(wchar_t *) = Load : &:r190_2, m189_5 -# 190| r190_4(glval) = VariableAddress[i] : -# 190| r190_5(int) = Load : &:r190_4, m187_5 -# 190| r190_6(glval) = PointerAdd[4] : r190_3, r190_5 -# 190| r190_7(wchar_t) = Load : &:r190_6, ~m187_2 -# 190| m190_8(wchar_t) = Store : &:r190_1, r190_7 -# 191| v191_1(void) = NoOp : -# 187| v187_6(void) = ReturnVoid : -# 187| v187_7(void) = UnmodeledUse : mu* -# 187| v187_8(void) = AliasedUse : ~m187_2 -# 187| v187_9(void) = ExitFunction : - -# 193| void PointerCompare(int*, int*) -# 193| Block 0 -# 193| v193_1(void) = EnterFunction : -# 193| m193_2(unknown) = AliasedDefinition : -# 193| mu193_3(unknown) = UnmodeledDefinition : -# 193| r193_4(glval) = VariableAddress[p] : -# 193| m193_5(int *) = InitializeParameter[p] : &:r193_4 -# 193| r193_6(int *) = Load : &:r193_4, m193_5 -# 193| m193_7(unknown) = InitializeIndirection[p] : &:r193_6 -# 193| m193_8(unknown) = Chi : total:m193_2, partial:m193_7 -# 193| r193_9(glval) = VariableAddress[q] : -# 193| m193_10(int *) = InitializeParameter[q] : &:r193_9 -# 193| r193_11(int *) = Load : &:r193_9, m193_10 -# 193| m193_12(unknown) = InitializeIndirection[q] : &:r193_11 -# 193| m193_13(unknown) = Chi : total:m193_8, partial:m193_12 -# 194| r194_1(glval) = VariableAddress[b] : -# 194| m194_2(bool) = Uninitialized[b] : &:r194_1 -# 196| r196_1(glval) = VariableAddress[p] : -# 196| r196_2(int *) = Load : &:r196_1, m193_5 -# 196| r196_3(glval) = VariableAddress[q] : -# 196| r196_4(int *) = Load : &:r196_3, m193_10 -# 196| r196_5(bool) = CompareEQ : r196_2, r196_4 -# 196| r196_6(glval) = VariableAddress[b] : -# 196| m196_7(bool) = Store : &:r196_6, r196_5 -# 197| r197_1(glval) = VariableAddress[p] : -# 197| r197_2(int *) = Load : &:r197_1, m193_5 -# 197| r197_3(glval) = VariableAddress[q] : -# 197| r197_4(int *) = Load : &:r197_3, m193_10 -# 197| r197_5(bool) = CompareNE : r197_2, r197_4 -# 197| r197_6(glval) = VariableAddress[b] : -# 197| m197_7(bool) = Store : &:r197_6, r197_5 -# 198| r198_1(glval) = VariableAddress[p] : -# 198| r198_2(int *) = Load : &:r198_1, m193_5 -# 198| r198_3(glval) = VariableAddress[q] : -# 198| r198_4(int *) = Load : &:r198_3, m193_10 -# 198| r198_5(bool) = CompareLT : r198_2, r198_4 -# 198| r198_6(glval) = VariableAddress[b] : -# 198| m198_7(bool) = Store : &:r198_6, r198_5 -# 199| r199_1(glval) = VariableAddress[p] : -# 199| r199_2(int *) = Load : &:r199_1, m193_5 -# 199| r199_3(glval) = VariableAddress[q] : -# 199| r199_4(int *) = Load : &:r199_3, m193_10 -# 199| r199_5(bool) = CompareGT : r199_2, r199_4 -# 199| r199_6(glval) = VariableAddress[b] : -# 199| m199_7(bool) = Store : &:r199_6, r199_5 -# 200| r200_1(glval) = VariableAddress[p] : -# 200| r200_2(int *) = Load : &:r200_1, m193_5 -# 200| r200_3(glval) = VariableAddress[q] : -# 200| r200_4(int *) = Load : &:r200_3, m193_10 -# 200| r200_5(bool) = CompareLE : r200_2, r200_4 -# 200| r200_6(glval) = VariableAddress[b] : -# 200| m200_7(bool) = Store : &:r200_6, r200_5 -# 201| r201_1(glval) = VariableAddress[p] : -# 201| r201_2(int *) = Load : &:r201_1, m193_5 -# 201| r201_3(glval) = VariableAddress[q] : -# 201| r201_4(int *) = Load : &:r201_3, m193_10 -# 201| r201_5(bool) = CompareGE : r201_2, r201_4 -# 201| r201_6(glval) = VariableAddress[b] : -# 201| m201_7(bool) = Store : &:r201_6, r201_5 -# 202| v202_1(void) = NoOp : -# 193| v193_14(void) = ReturnIndirection : &:r193_6, ~m193_13 -# 193| v193_15(void) = ReturnIndirection : &:r193_11, ~m193_13 -# 193| v193_16(void) = ReturnVoid : -# 193| v193_17(void) = UnmodeledUse : mu* -# 193| v193_18(void) = AliasedUse : ~m193_13 -# 193| v193_19(void) = ExitFunction : - -# 204| void PointerCrement(int*) -# 204| Block 0 -# 204| v204_1(void) = EnterFunction : -# 204| m204_2(unknown) = AliasedDefinition : -# 204| mu204_3(unknown) = UnmodeledDefinition : -# 204| r204_4(glval) = VariableAddress[p] : -# 204| m204_5(int *) = InitializeParameter[p] : &:r204_4 -# 204| r204_6(int *) = Load : &:r204_4, m204_5 -# 204| m204_7(unknown) = InitializeIndirection[p] : &:r204_6 -# 204| m204_8(unknown) = Chi : total:m204_2, partial:m204_7 -# 205| r205_1(glval) = VariableAddress[q] : -# 205| m205_2(int *) = Uninitialized[q] : &:r205_1 -# 207| r207_1(glval) = VariableAddress[p] : -# 207| r207_2(int *) = Load : &:r207_1, m204_5 -# 207| r207_3(int) = Constant[1] : -# 207| r207_4(int *) = PointerAdd[4] : r207_2, r207_3 -# 207| m207_5(int *) = Store : &:r207_1, r207_4 -# 207| r207_6(glval) = VariableAddress[q] : -# 207| m207_7(int *) = Store : &:r207_6, r207_4 -# 208| r208_1(glval) = VariableAddress[p] : -# 208| r208_2(int *) = Load : &:r208_1, m207_5 -# 208| r208_3(int) = Constant[1] : -# 208| r208_4(int *) = PointerSub[4] : r208_2, r208_3 -# 208| m208_5(int *) = Store : &:r208_1, r208_4 -# 208| r208_6(glval) = VariableAddress[q] : -# 208| m208_7(int *) = Store : &:r208_6, r208_4 -# 209| r209_1(glval) = VariableAddress[p] : -# 209| r209_2(int *) = Load : &:r209_1, m208_5 -# 209| r209_3(int) = Constant[1] : -# 209| r209_4(int *) = PointerAdd[4] : r209_2, r209_3 -# 209| m209_5(int *) = Store : &:r209_1, r209_4 -# 209| r209_6(glval) = VariableAddress[q] : -# 209| m209_7(int *) = Store : &:r209_6, r209_2 -# 210| r210_1(glval) = VariableAddress[p] : -# 210| r210_2(int *) = Load : &:r210_1, m209_5 -# 210| r210_3(int) = Constant[1] : -# 210| r210_4(int *) = PointerSub[4] : r210_2, r210_3 -# 210| m210_5(int *) = Store : &:r210_1, r210_4 -# 210| r210_6(glval) = VariableAddress[q] : -# 210| m210_7(int *) = Store : &:r210_6, r210_2 -# 211| v211_1(void) = NoOp : -# 204| v204_9(void) = ReturnIndirection : &:r204_6, ~m204_8 -# 204| v204_10(void) = ReturnVoid : -# 204| v204_11(void) = UnmodeledUse : mu* -# 204| v204_12(void) = AliasedUse : ~m204_8 -# 204| v204_13(void) = ExitFunction : - -# 213| void CompoundAssignment() -# 213| Block 0 -# 213| v213_1(void) = EnterFunction : -# 213| m213_2(unknown) = AliasedDefinition : -# 213| mu213_3(unknown) = UnmodeledDefinition : -# 215| r215_1(glval) = VariableAddress[x] : -# 215| r215_2(int) = Constant[5] : -# 215| m215_3(int) = Store : &:r215_1, r215_2 -# 216| r216_1(int) = Constant[7] : -# 216| r216_2(glval) = VariableAddress[x] : -# 216| r216_3(int) = Load : &:r216_2, m215_3 -# 216| r216_4(int) = Add : r216_3, r216_1 -# 216| m216_5(int) = Store : &:r216_2, r216_4 -# 219| r219_1(glval) = VariableAddress[y] : -# 219| r219_2(short) = Constant[5] : -# 219| m219_3(short) = Store : &:r219_1, r219_2 -# 220| r220_1(glval) = VariableAddress[x] : -# 220| r220_2(int) = Load : &:r220_1, m216_5 -# 220| r220_3(glval) = VariableAddress[y] : -# 220| r220_4(short) = Load : &:r220_3, m219_3 -# 220| r220_5(int) = Convert : r220_4 -# 220| r220_6(int) = Add : r220_5, r220_2 -# 220| r220_7(short) = Convert : r220_6 -# 220| m220_8(short) = Store : &:r220_3, r220_7 -# 223| r223_1(int) = Constant[1] : -# 223| r223_2(glval) = VariableAddress[y] : -# 223| r223_3(short) = Load : &:r223_2, m220_8 -# 223| r223_4(short) = ShiftLeft : r223_3, r223_1 -# 223| m223_5(short) = Store : &:r223_2, r223_4 -# 226| r226_1(glval) = VariableAddress[z] : -# 226| r226_2(long) = Constant[7] : -# 226| m226_3(long) = Store : &:r226_1, r226_2 -# 227| r227_1(float) = Constant[2.0] : -# 227| r227_2(glval) = VariableAddress[z] : -# 227| r227_3(long) = Load : &:r227_2, m226_3 -# 227| r227_4(float) = Convert : r227_3 -# 227| r227_5(float) = Add : r227_4, r227_1 -# 227| r227_6(long) = Convert : r227_5 -# 227| m227_7(long) = Store : &:r227_2, r227_6 -# 228| v228_1(void) = NoOp : -# 213| v213_4(void) = ReturnVoid : -# 213| v213_5(void) = UnmodeledUse : mu* -# 213| v213_6(void) = AliasedUse : ~m213_2 -# 213| v213_7(void) = ExitFunction : - -# 230| void UninitializedVariables() -# 230| Block 0 -# 230| v230_1(void) = EnterFunction : -# 230| m230_2(unknown) = AliasedDefinition : -# 230| mu230_3(unknown) = UnmodeledDefinition : -# 231| r231_1(glval) = VariableAddress[x] : -# 231| m231_2(int) = Uninitialized[x] : &:r231_1 -# 232| r232_1(glval) = VariableAddress[y] : -# 232| r232_2(glval) = VariableAddress[x] : -# 232| r232_3(int) = Load : &:r232_2, m231_2 -# 232| m232_4(int) = Store : &:r232_1, r232_3 -# 233| v233_1(void) = NoOp : -# 230| v230_4(void) = ReturnVoid : -# 230| v230_5(void) = UnmodeledUse : mu* -# 230| v230_6(void) = AliasedUse : ~m230_2 -# 230| v230_7(void) = ExitFunction : - -# 235| int Parameters(int, int) -# 235| Block 0 -# 235| v235_1(void) = EnterFunction : -# 235| m235_2(unknown) = AliasedDefinition : -# 235| mu235_3(unknown) = UnmodeledDefinition : -# 235| r235_4(glval) = VariableAddress[x] : -# 235| m235_5(int) = InitializeParameter[x] : &:r235_4 -# 235| r235_6(glval) = VariableAddress[y] : -# 235| m235_7(int) = InitializeParameter[y] : &:r235_6 -# 236| r236_1(glval) = VariableAddress[#return] : -# 236| r236_2(glval) = VariableAddress[x] : -# 236| r236_3(int) = Load : &:r236_2, m235_5 -# 236| r236_4(glval) = VariableAddress[y] : -# 236| r236_5(int) = Load : &:r236_4, m235_7 -# 236| r236_6(int) = Rem : r236_3, r236_5 -# 236| m236_7(int) = Store : &:r236_1, r236_6 -# 235| r235_8(glval) = VariableAddress[#return] : -# 235| v235_9(void) = ReturnValue : &:r235_8, m236_7 -# 235| v235_10(void) = UnmodeledUse : mu* -# 235| v235_11(void) = AliasedUse : ~m235_2 -# 235| v235_12(void) = ExitFunction : - -# 239| void IfStatements(bool, int, int) -# 239| Block 0 -# 239| v239_1(void) = EnterFunction : -# 239| m239_2(unknown) = AliasedDefinition : -# 239| mu239_3(unknown) = UnmodeledDefinition : -# 239| r239_4(glval) = VariableAddress[b] : -# 239| m239_5(bool) = InitializeParameter[b] : &:r239_4 -# 239| r239_6(glval) = VariableAddress[x] : -# 239| m239_7(int) = InitializeParameter[x] : &:r239_6 -# 239| r239_8(glval) = VariableAddress[y] : -# 239| m239_9(int) = InitializeParameter[y] : &:r239_8 -# 240| r240_1(glval) = VariableAddress[b] : -# 240| r240_2(bool) = Load : &:r240_1, m239_5 -# 240| v240_3(void) = ConditionalBranch : r240_2 -#-----| False -> Block 1 -#-----| True -> Block 7 - -# 243| Block 1 -# 243| r243_1(glval) = VariableAddress[b] : -# 243| r243_2(bool) = Load : &:r243_1, m239_5 -# 243| v243_3(void) = ConditionalBranch : r243_2 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 244| Block 2 -# 244| r244_1(glval) = VariableAddress[y] : -# 244| r244_2(int) = Load : &:r244_1, m239_9 -# 244| r244_3(glval) = VariableAddress[x] : -# 244| m244_4(int) = Store : &:r244_3, r244_2 -#-----| Goto -> Block 3 - -# 247| Block 3 -# 247| m247_1(int) = Phi : from 1:m239_7, from 2:m244_4 -# 247| r247_2(glval) = VariableAddress[x] : -# 247| r247_3(int) = Load : &:r247_2, m247_1 -# 247| r247_4(int) = Constant[7] : -# 247| r247_5(bool) = CompareLT : r247_3, r247_4 -# 247| v247_6(void) = ConditionalBranch : r247_5 -#-----| False -> Block 5 -#-----| True -> Block 4 - -# 248| Block 4 -# 248| r248_1(int) = Constant[2] : -# 248| r248_2(glval) = VariableAddress[x] : -# 248| m248_3(int) = Store : &:r248_2, r248_1 -#-----| Goto -> Block 6 - -# 250| Block 5 -# 250| r250_1(int) = Constant[7] : -# 250| r250_2(glval) = VariableAddress[x] : -# 250| m250_3(int) = Store : &:r250_2, r250_1 -#-----| Goto -> Block 6 - -# 251| Block 6 -# 251| v251_1(void) = NoOp : -# 239| v239_10(void) = ReturnVoid : -# 239| v239_11(void) = UnmodeledUse : mu* -# 239| v239_12(void) = AliasedUse : ~m239_2 -# 239| v239_13(void) = ExitFunction : - -# 240| Block 7 -# 240| v240_4(void) = NoOp : -#-----| Goto -> Block 1 - -# 253| void WhileStatements(int) -# 253| Block 0 -# 253| v253_1(void) = EnterFunction : -# 253| m253_2(unknown) = AliasedDefinition : -# 253| mu253_3(unknown) = UnmodeledDefinition : -# 253| r253_4(glval) = VariableAddress[n] : -# 253| m253_5(int) = InitializeParameter[n] : &:r253_4 -#-----| Goto -> Block 3 - -# 255| Block 1 -# 255| r255_1(int) = Constant[1] : -# 255| r255_2(glval) = VariableAddress[n] : -# 255| r255_3(int) = Load : &:r255_2, m254_1 -# 255| r255_4(int) = Sub : r255_3, r255_1 -# 255| m255_5(int) = Store : &:r255_2, r255_4 -#-----| Goto (back edge) -> Block 3 - -# 257| Block 2 -# 257| v257_1(void) = NoOp : -# 253| v253_6(void) = ReturnVoid : -# 253| v253_7(void) = UnmodeledUse : mu* -# 253| v253_8(void) = AliasedUse : ~m253_2 -# 253| v253_9(void) = ExitFunction : - -# 254| Block 3 -# 254| m254_1(int) = Phi : from 0:m253_5, from 1:m255_5 -# 254| r254_2(glval) = VariableAddress[n] : -# 254| r254_3(int) = Load : &:r254_2, m254_1 -# 254| r254_4(int) = Constant[0] : -# 254| r254_5(bool) = CompareGT : r254_3, r254_4 -# 254| v254_6(void) = ConditionalBranch : r254_5 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 259| void DoStatements(int) -# 259| Block 0 -# 259| v259_1(void) = EnterFunction : -# 259| m259_2(unknown) = AliasedDefinition : -# 259| mu259_3(unknown) = UnmodeledDefinition : -# 259| r259_4(glval) = VariableAddress[n] : -# 259| m259_5(int) = InitializeParameter[n] : &:r259_4 -#-----| Goto -> Block 1 - -# 261| Block 1 -# 261| m261_1(int) = Phi : from 0:m259_5, from 1:m261_6 -# 261| r261_2(int) = Constant[1] : -# 261| r261_3(glval) = VariableAddress[n] : -# 261| r261_4(int) = Load : &:r261_3, m261_1 -# 261| r261_5(int) = Sub : r261_4, r261_2 -# 261| m261_6(int) = Store : &:r261_3, r261_5 -# 262| r262_1(glval) = VariableAddress[n] : -# 262| r262_2(int) = Load : &:r262_1, m261_6 -# 262| r262_3(int) = Constant[0] : -# 262| r262_4(bool) = CompareGT : r262_2, r262_3 -# 262| v262_5(void) = ConditionalBranch : r262_4 -#-----| False -> Block 2 -#-----| True (back edge) -> Block 1 - -# 263| Block 2 -# 263| v263_1(void) = NoOp : -# 259| v259_6(void) = ReturnVoid : -# 259| v259_7(void) = UnmodeledUse : mu* -# 259| v259_8(void) = AliasedUse : ~m259_2 -# 259| v259_9(void) = ExitFunction : - -# 265| void For_Empty() -# 265| Block 0 -# 265| v265_1(void) = EnterFunction : -# 265| m265_2(unknown) = AliasedDefinition : -# 265| mu265_3(unknown) = UnmodeledDefinition : -# 266| r266_1(glval) = VariableAddress[j] : -# 266| m266_2(int) = Uninitialized[j] : &:r266_1 -#-----| Goto -> Block 1 - -# 268| Block 1 -# 268| v268_1(void) = NoOp : -#-----| Goto (back edge) -> Block 1 - -# 272| void For_Init() -# 272| Block 0 -# 272| v272_1(void) = EnterFunction : -# 272| m272_2(unknown) = AliasedDefinition : -# 272| mu272_3(unknown) = UnmodeledDefinition : -# 273| r273_1(glval) = VariableAddress[i] : -# 273| r273_2(int) = Constant[0] : -# 273| m273_3(int) = Store : &:r273_1, r273_2 -#-----| Goto -> Block 1 - -# 274| Block 1 -# 274| v274_1(void) = NoOp : -#-----| Goto (back edge) -> Block 1 - -# 278| void For_Condition() -# 278| Block 0 -# 278| v278_1(void) = EnterFunction : -# 278| m278_2(unknown) = AliasedDefinition : -# 278| mu278_3(unknown) = UnmodeledDefinition : -# 279| r279_1(glval) = VariableAddress[i] : -# 279| r279_2(int) = Constant[0] : -# 279| m279_3(int) = Store : &:r279_1, r279_2 -#-----| Goto -> Block 1 - -# 280| Block 1 -# 280| r280_1(glval) = VariableAddress[i] : -# 280| r280_2(int) = Load : &:r280_1, m279_3 -# 280| r280_3(int) = Constant[10] : -# 280| r280_4(bool) = CompareLT : r280_2, r280_3 -# 280| v280_5(void) = ConditionalBranch : r280_4 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 281| Block 2 -# 281| v281_1(void) = NoOp : -#-----| Goto (back edge) -> Block 1 - -# 278| Block 3 -# 278| v278_4(void) = Unreached : - -# 285| void For_Update() -# 285| Block 0 -# 285| v285_1(void) = EnterFunction : -# 285| m285_2(unknown) = AliasedDefinition : -# 285| mu285_3(unknown) = UnmodeledDefinition : -# 286| r286_1(glval) = VariableAddress[i] : -# 286| r286_2(int) = Constant[0] : -# 286| m286_3(int) = Store : &:r286_1, r286_2 -#-----| Goto -> Block 1 - -# 288| Block 1 -# 288| m288_1(int) = Phi : from 0:m286_3, from 1:m287_5 -# 288| v288_2(void) = NoOp : -# 287| r287_1(int) = Constant[1] : -# 287| r287_2(glval) = VariableAddress[i] : -# 287| r287_3(int) = Load : &:r287_2, m288_1 -# 287| r287_4(int) = Add : r287_3, r287_1 -# 287| m287_5(int) = Store : &:r287_2, r287_4 -#-----| Goto (back edge) -> Block 1 - -# 292| void For_InitCondition() -# 292| Block 0 -# 292| v292_1(void) = EnterFunction : -# 292| m292_2(unknown) = AliasedDefinition : -# 292| mu292_3(unknown) = UnmodeledDefinition : -# 293| r293_1(glval) = VariableAddress[i] : -# 293| r293_2(int) = Constant[0] : -# 293| m293_3(int) = Store : &:r293_1, r293_2 -#-----| Goto -> Block 1 - -# 293| Block 1 -# 293| r293_4(glval) = VariableAddress[i] : -# 293| r293_5(int) = Load : &:r293_4, m293_3 -# 293| r293_6(int) = Constant[10] : -# 293| r293_7(bool) = CompareLT : r293_5, r293_6 -# 293| v293_8(void) = ConditionalBranch : r293_7 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 294| Block 2 -# 294| v294_1(void) = NoOp : -#-----| Goto (back edge) -> Block 1 - -# 292| Block 3 -# 292| v292_4(void) = Unreached : - -# 298| void For_InitUpdate() -# 298| Block 0 -# 298| v298_1(void) = EnterFunction : -# 298| m298_2(unknown) = AliasedDefinition : -# 298| mu298_3(unknown) = UnmodeledDefinition : -# 299| r299_1(glval) = VariableAddress[i] : -# 299| r299_2(int) = Constant[0] : -# 299| m299_3(int) = Store : &:r299_1, r299_2 -#-----| Goto -> Block 1 - -# 300| Block 1 -# 300| m300_1(int) = Phi : from 0:m299_3, from 1:m299_8 -# 300| v300_2(void) = NoOp : -# 299| r299_4(int) = Constant[1] : -# 299| r299_5(glval) = VariableAddress[i] : -# 299| r299_6(int) = Load : &:r299_5, m300_1 -# 299| r299_7(int) = Add : r299_6, r299_4 -# 299| m299_8(int) = Store : &:r299_5, r299_7 -#-----| Goto (back edge) -> Block 1 - -# 304| void For_ConditionUpdate() -# 304| Block 0 -# 304| v304_1(void) = EnterFunction : -# 304| m304_2(unknown) = AliasedDefinition : -# 304| mu304_3(unknown) = UnmodeledDefinition : -# 305| r305_1(glval) = VariableAddress[i] : -# 305| r305_2(int) = Constant[0] : -# 305| m305_3(int) = Store : &:r305_1, r305_2 -#-----| Goto -> Block 1 - -# 306| Block 1 -# 306| m306_1(int) = Phi : from 0:m305_3, from 2:m306_11 -# 306| r306_2(glval) = VariableAddress[i] : -# 306| r306_3(int) = Load : &:r306_2, m306_1 -# 306| r306_4(int) = Constant[10] : -# 306| r306_5(bool) = CompareLT : r306_3, r306_4 -# 306| v306_6(void) = ConditionalBranch : r306_5 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 307| Block 2 -# 307| v307_1(void) = NoOp : -# 306| r306_7(int) = Constant[1] : -# 306| r306_8(glval) = VariableAddress[i] : -# 306| r306_9(int) = Load : &:r306_8, m306_1 -# 306| r306_10(int) = Add : r306_9, r306_7 -# 306| m306_11(int) = Store : &:r306_8, r306_10 -#-----| Goto (back edge) -> Block 1 - -# 309| Block 3 -# 309| v309_1(void) = NoOp : -# 304| v304_4(void) = ReturnVoid : -# 304| v304_5(void) = UnmodeledUse : mu* -# 304| v304_6(void) = AliasedUse : ~m304_2 -# 304| v304_7(void) = ExitFunction : - -# 311| void For_InitConditionUpdate() -# 311| Block 0 -# 311| v311_1(void) = EnterFunction : -# 311| m311_2(unknown) = AliasedDefinition : -# 311| mu311_3(unknown) = UnmodeledDefinition : -# 312| r312_1(glval) = VariableAddress[i] : -# 312| r312_2(int) = Constant[0] : -# 312| m312_3(int) = Store : &:r312_1, r312_2 -#-----| Goto -> Block 1 - -# 312| Block 1 -# 312| m312_4(int) = Phi : from 0:m312_3, from 2:m312_14 -# 312| r312_5(glval) = VariableAddress[i] : -# 312| r312_6(int) = Load : &:r312_5, m312_4 -# 312| r312_7(int) = Constant[10] : -# 312| r312_8(bool) = CompareLT : r312_6, r312_7 -# 312| v312_9(void) = ConditionalBranch : r312_8 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 313| Block 2 -# 313| v313_1(void) = NoOp : -# 312| r312_10(int) = Constant[1] : -# 312| r312_11(glval) = VariableAddress[i] : -# 312| r312_12(int) = Load : &:r312_11, m312_4 -# 312| r312_13(int) = Add : r312_12, r312_10 -# 312| m312_14(int) = Store : &:r312_11, r312_13 -#-----| Goto (back edge) -> Block 1 - -# 315| Block 3 -# 315| v315_1(void) = NoOp : -# 311| v311_4(void) = ReturnVoid : -# 311| v311_5(void) = UnmodeledUse : mu* -# 311| v311_6(void) = AliasedUse : ~m311_2 -# 311| v311_7(void) = ExitFunction : - -# 317| void For_Break() -# 317| Block 0 -# 317| v317_1(void) = EnterFunction : -# 317| m317_2(unknown) = AliasedDefinition : -# 317| mu317_3(unknown) = UnmodeledDefinition : -# 318| r318_1(glval) = VariableAddress[i] : -# 318| r318_2(int) = Constant[0] : -# 318| m318_3(int) = Store : &:r318_1, r318_2 -#-----| Goto -> Block 1 - -# 318| Block 1 -# 318| m318_4(int) = Phi : from 0:m318_3, from 2:m318_14 -# 318| r318_5(glval) = VariableAddress[i] : -# 318| r318_6(int) = Load : &:r318_5, m318_4 -# 318| r318_7(int) = Constant[10] : -# 318| r318_8(bool) = CompareLT : r318_6, r318_7 -# 318| v318_9(void) = ConditionalBranch : r318_8 -#-----| False -> Block 5 -#-----| True -> Block 3 - -# 318| Block 2 -# 318| r318_10(int) = Constant[1] : -# 318| r318_11(glval) = VariableAddress[i] : -# 318| r318_12(int) = Load : &:r318_11, m318_4 -# 318| r318_13(int) = Add : r318_12, r318_10 -# 318| m318_14(int) = Store : &:r318_11, r318_13 -#-----| Goto (back edge) -> Block 1 - -# 319| Block 3 -# 319| r319_1(glval) = VariableAddress[i] : -# 319| r319_2(int) = Load : &:r319_1, m318_4 -# 319| r319_3(int) = Constant[5] : -# 319| r319_4(bool) = CompareEQ : r319_2, r319_3 -# 319| v319_5(void) = ConditionalBranch : r319_4 -#-----| False -> Block 2 -#-----| True -> Block 4 - -# 320| Block 4 -# 320| v320_1(void) = NoOp : -#-----| Goto -> Block 5 - -# 322| Block 5 -# 322| v322_1(void) = NoOp : -# 323| v323_1(void) = NoOp : -# 317| v317_4(void) = ReturnVoid : -# 317| v317_5(void) = UnmodeledUse : mu* -# 317| v317_6(void) = AliasedUse : ~m317_2 -# 317| v317_7(void) = ExitFunction : - -# 325| void For_Continue_Update() -# 325| Block 0 -# 325| v325_1(void) = EnterFunction : -# 325| m325_2(unknown) = AliasedDefinition : -# 325| mu325_3(unknown) = UnmodeledDefinition : -# 326| r326_1(glval) = VariableAddress[i] : -# 326| r326_2(int) = Constant[0] : -# 326| m326_3(int) = Store : &:r326_1, r326_2 -#-----| Goto -> Block 1 - -# 326| Block 1 -# 326| m326_4(int) = Phi : from 0:m326_3, from 4:m326_15 -# 326| r326_5(glval) = VariableAddress[i] : -# 326| r326_6(int) = Load : &:r326_5, m326_4 -# 326| r326_7(int) = Constant[10] : -# 326| r326_8(bool) = CompareLT : r326_6, r326_7 -# 326| v326_9(void) = ConditionalBranch : r326_8 -#-----| False -> Block 5 -#-----| True -> Block 2 - -# 327| Block 2 -# 327| r327_1(glval) = VariableAddress[i] : -# 327| r327_2(int) = Load : &:r327_1, m326_4 -# 327| r327_3(int) = Constant[5] : -# 327| r327_4(bool) = CompareEQ : r327_2, r327_3 -# 327| v327_5(void) = ConditionalBranch : r327_4 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 328| Block 3 -# 328| v328_1(void) = NoOp : -#-----| Goto -> Block 4 - -# 326| Block 4 -# 326| v326_10(void) = NoOp : -# 326| r326_11(int) = Constant[1] : -# 326| r326_12(glval) = VariableAddress[i] : -# 326| r326_13(int) = Load : &:r326_12, m326_4 -# 326| r326_14(int) = Add : r326_13, r326_11 -# 326| m326_15(int) = Store : &:r326_12, r326_14 -#-----| Goto (back edge) -> Block 1 - -# 331| Block 5 -# 331| v331_1(void) = NoOp : -# 325| v325_4(void) = ReturnVoid : -# 325| v325_5(void) = UnmodeledUse : mu* -# 325| v325_6(void) = AliasedUse : ~m325_2 -# 325| v325_7(void) = ExitFunction : - -# 333| void For_Continue_NoUpdate() -# 333| Block 0 -# 333| v333_1(void) = EnterFunction : -# 333| m333_2(unknown) = AliasedDefinition : -# 333| mu333_3(unknown) = UnmodeledDefinition : -# 334| r334_1(glval) = VariableAddress[i] : -# 334| r334_2(int) = Constant[0] : -# 334| m334_3(int) = Store : &:r334_1, r334_2 -#-----| Goto -> Block 1 - -# 334| Block 1 -# 334| r334_4(glval) = VariableAddress[i] : -# 334| r334_5(int) = Load : &:r334_4, m334_3 -# 334| r334_6(int) = Constant[10] : -# 334| r334_7(bool) = CompareLT : r334_5, r334_6 -# 334| v334_8(void) = ConditionalBranch : r334_7 -#-----| False -> Block 4 -#-----| True -> Block 2 - -# 335| Block 2 -# 335| r335_1(glval) = VariableAddress[i] : -# 335| r335_2(int) = Load : &:r335_1, m334_3 -# 335| r335_3(int) = Constant[5] : -# 335| r335_4(bool) = CompareEQ : r335_2, r335_3 -# 335| v335_5(void) = ConditionalBranch : r335_4 -#-----| False -> Block 3 -#-----| True -> Block 4 - -# 334| Block 3 -# 334| v334_9(void) = NoOp : -#-----| Goto (back edge) -> Block 1 - -# 333| Block 4 -# 333| v333_4(void) = Unreached : - -# 341| int Dereference(int*) -# 341| Block 0 -# 341| v341_1(void) = EnterFunction : -# 341| m341_2(unknown) = AliasedDefinition : -# 341| mu341_3(unknown) = UnmodeledDefinition : -# 341| r341_4(glval) = VariableAddress[p] : -# 341| m341_5(int *) = InitializeParameter[p] : &:r341_4 -# 341| r341_6(int *) = Load : &:r341_4, m341_5 -# 341| m341_7(unknown) = InitializeIndirection[p] : &:r341_6 -# 341| m341_8(unknown) = Chi : total:m341_2, partial:m341_7 -# 342| r342_1(int) = Constant[1] : -# 342| r342_2(glval) = VariableAddress[p] : -# 342| r342_3(int *) = Load : &:r342_2, m341_5 -# 342| r342_4(glval) = CopyValue : r342_3 -# 342| m342_5(int) = Store : &:r342_4, r342_1 -# 342| m342_6(unknown) = Chi : total:m341_8, partial:m342_5 -# 343| r343_1(glval) = VariableAddress[#return] : -# 343| r343_2(glval) = VariableAddress[p] : -# 343| r343_3(int *) = Load : &:r343_2, m341_5 -# 343| r343_4(int) = Load : &:r343_3, ~m342_6 -# 343| m343_5(int) = Store : &:r343_1, r343_4 -# 341| v341_9(void) = ReturnIndirection : &:r341_6, ~m342_6 -# 341| r341_10(glval) = VariableAddress[#return] : -# 341| v341_11(void) = ReturnValue : &:r341_10, m343_5 -# 341| v341_12(void) = UnmodeledUse : mu* -# 341| v341_13(void) = AliasedUse : ~m342_6 -# 341| v341_14(void) = ExitFunction : - -# 348| int* AddressOf() -# 348| Block 0 -# 348| v348_1(void) = EnterFunction : -# 348| m348_2(unknown) = AliasedDefinition : -# 348| mu348_3(unknown) = UnmodeledDefinition : -# 349| r349_1(glval) = VariableAddress[#return] : -# 349| r349_2(glval) = VariableAddress[g] : -# 349| r349_3(int *) = CopyValue : r349_2 -# 349| m349_4(int *) = Store : &:r349_1, r349_3 -# 348| r348_4(glval) = VariableAddress[#return] : -# 348| v348_5(void) = ReturnValue : &:r348_4, m349_4 -# 348| v348_6(void) = UnmodeledUse : mu* -# 348| v348_7(void) = AliasedUse : ~m348_2 -# 348| v348_8(void) = ExitFunction : - -# 352| void Break(int) -# 352| Block 0 -# 352| v352_1(void) = EnterFunction : -# 352| m352_2(unknown) = AliasedDefinition : -# 352| mu352_3(unknown) = UnmodeledDefinition : -# 352| r352_4(glval) = VariableAddress[n] : -# 352| m352_5(int) = InitializeParameter[n] : &:r352_4 -#-----| Goto -> Block 5 - -# 354| Block 1 -# 354| r354_1(glval) = VariableAddress[n] : -# 354| r354_2(int) = Load : &:r354_1, m353_1 -# 354| r354_3(int) = Constant[1] : -# 354| r354_4(bool) = CompareEQ : r354_2, r354_3 -# 354| v354_5(void) = ConditionalBranch : r354_4 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 355| Block 2 -# 355| v355_1(void) = NoOp : -#-----| Goto -> Block 4 - -# 356| Block 3 -# 356| r356_1(int) = Constant[1] : -# 356| r356_2(glval) = VariableAddress[n] : -# 356| r356_3(int) = Load : &:r356_2, m353_1 -# 356| r356_4(int) = Sub : r356_3, r356_1 -# 356| m356_5(int) = Store : &:r356_2, r356_4 -#-----| Goto (back edge) -> Block 5 - -# 357| Block 4 -# 357| v357_1(void) = NoOp : -# 358| v358_1(void) = NoOp : -# 352| v352_6(void) = ReturnVoid : -# 352| v352_7(void) = UnmodeledUse : mu* -# 352| v352_8(void) = AliasedUse : ~m352_2 -# 352| v352_9(void) = ExitFunction : - -# 353| Block 5 -# 353| m353_1(int) = Phi : from 0:m352_5, from 3:m356_5 -# 353| r353_2(glval) = VariableAddress[n] : -# 353| r353_3(int) = Load : &:r353_2, m353_1 -# 353| r353_4(int) = Constant[0] : -# 353| r353_5(bool) = CompareGT : r353_3, r353_4 -# 353| v353_6(void) = ConditionalBranch : r353_5 -#-----| False -> Block 4 -#-----| True -> Block 1 - -# 360| void Continue(int) -# 360| Block 0 -# 360| v360_1(void) = EnterFunction : -# 360| m360_2(unknown) = AliasedDefinition : -# 360| mu360_3(unknown) = UnmodeledDefinition : -# 360| r360_4(glval) = VariableAddress[n] : -# 360| m360_5(int) = InitializeParameter[n] : &:r360_4 -#-----| Goto -> Block 1 - -# 362| Block 1 -# 362| m362_1(int) = Phi : from 0:m360_5, from 4:m361_1 -# 362| r362_2(glval) = VariableAddress[n] : -# 362| r362_3(int) = Load : &:r362_2, m362_1 -# 362| r362_4(int) = Constant[1] : -# 362| r362_5(bool) = CompareEQ : r362_3, r362_4 -# 362| v362_6(void) = ConditionalBranch : r362_5 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 363| Block 2 -# 363| v363_1(void) = NoOp : -#-----| Goto -> Block 4 - -# 365| Block 3 -# 365| r365_1(int) = Constant[1] : -# 365| r365_2(glval) = VariableAddress[n] : -# 365| r365_3(int) = Load : &:r365_2, m362_1 -# 365| r365_4(int) = Sub : r365_3, r365_1 -# 365| m365_5(int) = Store : &:r365_2, r365_4 -#-----| Goto -> Block 4 - -# 361| Block 4 -# 361| m361_1(int) = Phi : from 2:m362_1, from 3:m365_5 -# 361| v361_2(void) = NoOp : -# 366| r366_1(glval) = VariableAddress[n] : -# 366| r366_2(int) = Load : &:r366_1, m361_1 -# 366| r366_3(int) = Constant[0] : -# 366| r366_4(bool) = CompareGT : r366_2, r366_3 -# 366| v366_5(void) = ConditionalBranch : r366_4 -#-----| False -> Block 5 -#-----| True (back edge) -> Block 1 - -# 367| Block 5 -# 367| v367_1(void) = NoOp : -# 360| v360_6(void) = ReturnVoid : -# 360| v360_7(void) = UnmodeledUse : mu* -# 360| v360_8(void) = AliasedUse : ~m360_2 -# 360| v360_9(void) = ExitFunction : - -# 372| void Call() -# 372| Block 0 -# 372| v372_1(void) = EnterFunction : -# 372| m372_2(unknown) = AliasedDefinition : -# 372| mu372_3(unknown) = UnmodeledDefinition : -# 373| r373_1(glval) = FunctionAddress[VoidFunc] : -# 373| v373_2(void) = Call : func:r373_1 -# 373| m373_3(unknown) = ^CallSideEffect : ~m372_2 -# 373| m373_4(unknown) = Chi : total:m372_2, partial:m373_3 -# 374| v374_1(void) = NoOp : -# 372| v372_4(void) = ReturnVoid : -# 372| v372_5(void) = UnmodeledUse : mu* -# 372| v372_6(void) = AliasedUse : ~m373_4 -# 372| v372_7(void) = ExitFunction : - -# 376| int CallAdd(int, int) -# 376| Block 0 -# 376| v376_1(void) = EnterFunction : -# 376| m376_2(unknown) = AliasedDefinition : -# 376| mu376_3(unknown) = UnmodeledDefinition : -# 376| r376_4(glval) = VariableAddress[x] : -# 376| m376_5(int) = InitializeParameter[x] : &:r376_4 -# 376| r376_6(glval) = VariableAddress[y] : -# 376| m376_7(int) = InitializeParameter[y] : &:r376_6 -# 377| r377_1(glval) = VariableAddress[#return] : -# 377| r377_2(glval) = FunctionAddress[Add] : -# 377| r377_3(glval) = VariableAddress[x] : -# 377| r377_4(int) = Load : &:r377_3, m376_5 -# 377| r377_5(glval) = VariableAddress[y] : -# 377| r377_6(int) = Load : &:r377_5, m376_7 -# 377| r377_7(int) = Call : func:r377_2, 0:r377_4, 1:r377_6 -# 377| m377_8(unknown) = ^CallSideEffect : ~m376_2 -# 377| m377_9(unknown) = Chi : total:m376_2, partial:m377_8 -# 377| m377_10(int) = Store : &:r377_1, r377_7 -# 376| r376_8(glval) = VariableAddress[#return] : -# 376| v376_9(void) = ReturnValue : &:r376_8, m377_10 -# 376| v376_10(void) = UnmodeledUse : mu* -# 376| v376_11(void) = AliasedUse : ~m377_9 -# 376| v376_12(void) = ExitFunction : - -# 380| int Comma(int, int) -# 380| Block 0 -# 380| v380_1(void) = EnterFunction : -# 380| m380_2(unknown) = AliasedDefinition : -# 380| mu380_3(unknown) = UnmodeledDefinition : -# 380| r380_4(glval) = VariableAddress[x] : -# 380| m380_5(int) = InitializeParameter[x] : &:r380_4 -# 380| r380_6(glval) = VariableAddress[y] : -# 380| m380_7(int) = InitializeParameter[y] : &:r380_6 -# 381| r381_1(glval) = VariableAddress[#return] : -# 381| r381_2(glval) = FunctionAddress[VoidFunc] : -# 381| v381_3(void) = Call : func:r381_2 -# 381| m381_4(unknown) = ^CallSideEffect : ~m380_2 -# 381| m381_5(unknown) = Chi : total:m380_2, partial:m381_4 -# 381| r381_6(glval) = FunctionAddress[CallAdd] : -# 381| r381_7(glval) = VariableAddress[x] : -# 381| r381_8(int) = Load : &:r381_7, m380_5 -# 381| r381_9(glval) = VariableAddress[y] : -# 381| r381_10(int) = Load : &:r381_9, m380_7 -# 381| r381_11(int) = Call : func:r381_6, 0:r381_8, 1:r381_10 -# 381| m381_12(unknown) = ^CallSideEffect : ~m381_5 -# 381| m381_13(unknown) = Chi : total:m381_5, partial:m381_12 -# 381| r381_14(int) = CopyValue : r381_11 -# 381| m381_15(int) = Store : &:r381_1, r381_14 -# 380| r380_8(glval) = VariableAddress[#return] : -# 380| v380_9(void) = ReturnValue : &:r380_8, m381_15 -# 380| v380_10(void) = UnmodeledUse : mu* -# 380| v380_11(void) = AliasedUse : ~m381_13 -# 380| v380_12(void) = ExitFunction : - -# 384| void Switch(int) -# 384| Block 0 -# 384| v384_1(void) = EnterFunction : -# 384| m384_2(unknown) = AliasedDefinition : -# 384| mu384_3(unknown) = UnmodeledDefinition : -# 384| r384_4(glval) = VariableAddress[x] : -# 384| m384_5(int) = InitializeParameter[x] : &:r384_4 -# 385| r385_1(glval) = VariableAddress[y] : -# 385| m385_2(int) = Uninitialized[y] : &:r385_1 -# 386| r386_1(glval) = VariableAddress[x] : -# 386| r386_2(int) = Load : &:r386_1, m384_5 -# 386| v386_3(void) = Switch : r386_2 -#-----| Case[-1] -> Block 1 -#-----| Case[1] -> Block 2 -#-----| Case[2] -> Block 3 -#-----| Case[3] -> Block 4 -#-----| Case[4] -> Block 5 -#-----| Default -> Block 6 - -# 389| Block 1 -# 389| v389_1(void) = NoOp : -# 390| r390_1(int) = Constant[-1] : -# 390| r390_2(glval) = VariableAddress[y] : -# 390| m390_3(int) = Store : &:r390_2, r390_1 -# 391| v391_1(void) = NoOp : -#-----| Goto -> Block 7 - -# 393| Block 2 -# 393| v393_1(void) = NoOp : -#-----| Goto -> Block 3 - -# 394| Block 3 -# 394| v394_1(void) = NoOp : -# 395| r395_1(int) = Constant[1] : -# 395| r395_2(glval) = VariableAddress[y] : -# 395| m395_3(int) = Store : &:r395_2, r395_1 -# 396| v396_1(void) = NoOp : -#-----| Goto -> Block 7 - -# 398| Block 4 -# 398| v398_1(void) = NoOp : -# 399| r399_1(int) = Constant[3] : -# 399| r399_2(glval) = VariableAddress[y] : -# 399| m399_3(int) = Store : &:r399_2, r399_1 -#-----| Goto -> Block 5 - -# 400| Block 5 -# 400| v400_1(void) = NoOp : -# 401| r401_1(int) = Constant[4] : -# 401| r401_2(glval) = VariableAddress[y] : -# 401| m401_3(int) = Store : &:r401_2, r401_1 -# 402| v402_1(void) = NoOp : -#-----| Goto -> Block 7 - -# 404| Block 6 -# 404| v404_1(void) = NoOp : -# 405| r405_1(int) = Constant[0] : -# 405| r405_2(glval) = VariableAddress[y] : -# 405| m405_3(int) = Store : &:r405_2, r405_1 -# 406| v406_1(void) = NoOp : -#-----| Goto -> Block 7 - -# 409| Block 7 -# 409| v409_1(void) = NoOp : -# 410| v410_1(void) = NoOp : -# 384| v384_6(void) = ReturnVoid : -# 384| v384_7(void) = UnmodeledUse : mu* -# 384| v384_8(void) = AliasedUse : ~m384_2 -# 384| v384_9(void) = ExitFunction : - -# 422| Point ReturnStruct(Point) -# 422| Block 0 -# 422| v422_1(void) = EnterFunction : -# 422| m422_2(unknown) = AliasedDefinition : -# 422| mu422_3(unknown) = UnmodeledDefinition : -# 422| r422_4(glval) = VariableAddress[pt] : -# 422| m422_5(Point) = InitializeParameter[pt] : &:r422_4 -# 423| r423_1(glval) = VariableAddress[#return] : -# 423| r423_2(glval) = VariableAddress[pt] : -# 423| r423_3(Point) = Load : &:r423_2, m422_5 -# 423| m423_4(Point) = Store : &:r423_1, r423_3 -# 422| r422_6(glval) = VariableAddress[#return] : -# 422| v422_7(void) = ReturnValue : &:r422_6, m423_4 -# 422| v422_8(void) = UnmodeledUse : mu* -# 422| v422_9(void) = AliasedUse : ~m422_2 -# 422| v422_10(void) = ExitFunction : - -# 426| void FieldAccess() -# 426| Block 0 -# 426| v426_1(void) = EnterFunction : -# 426| m426_2(unknown) = AliasedDefinition : -# 426| mu426_3(unknown) = UnmodeledDefinition : -# 427| r427_1(glval) = VariableAddress[pt] : -# 427| m427_2(Point) = Uninitialized[pt] : &:r427_1 -# 428| r428_1(int) = Constant[5] : -# 428| r428_2(glval) = VariableAddress[pt] : -# 428| r428_3(glval) = FieldAddress[x] : r428_2 -# 428| m428_4(int) = Store : &:r428_3, r428_1 -# 428| m428_5(Point) = Chi : total:m427_2, partial:m428_4 -# 429| r429_1(glval) = VariableAddress[pt] : -# 429| r429_2(glval) = FieldAddress[x] : r429_1 -# 429| r429_3(int) = Load : &:r429_2, m428_4 -# 429| r429_4(glval) = VariableAddress[pt] : -# 429| r429_5(glval) = FieldAddress[y] : r429_4 -# 429| m429_6(int) = Store : &:r429_5, r429_3 -# 429| m429_7(Point) = Chi : total:m428_5, partial:m429_6 -# 430| r430_1(glval) = VariableAddress[p] : -# 430| r430_2(glval) = VariableAddress[pt] : -# 430| r430_3(glval) = FieldAddress[y] : r430_2 -# 430| r430_4(int *) = CopyValue : r430_3 -# 430| m430_5(int *) = Store : &:r430_1, r430_4 -# 431| v431_1(void) = NoOp : -# 426| v426_4(void) = ReturnVoid : -# 426| v426_5(void) = UnmodeledUse : mu* -# 426| v426_6(void) = AliasedUse : ~m426_2 -# 426| v426_7(void) = ExitFunction : - -# 433| void LogicalOr(bool, bool) -# 433| Block 0 -# 433| v433_1(void) = EnterFunction : -# 433| m433_2(unknown) = AliasedDefinition : -# 433| mu433_3(unknown) = UnmodeledDefinition : -# 433| r433_4(glval) = VariableAddress[a] : -# 433| m433_5(bool) = InitializeParameter[a] : &:r433_4 -# 433| r433_6(glval) = VariableAddress[b] : -# 433| m433_7(bool) = InitializeParameter[b] : &:r433_6 -# 434| r434_1(glval) = VariableAddress[x] : -# 434| m434_2(int) = Uninitialized[x] : &:r434_1 -# 435| r435_1(glval) = VariableAddress[a] : -# 435| r435_2(bool) = Load : &:r435_1, m433_5 -# 435| v435_3(void) = ConditionalBranch : r435_2 -#-----| False -> Block 1 -#-----| True -> Block 2 - -# 435| Block 1 -# 435| r435_4(glval) = VariableAddress[b] : -# 435| r435_5(bool) = Load : &:r435_4, m433_7 -# 435| v435_6(void) = ConditionalBranch : r435_5 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 436| Block 2 -# 436| r436_1(int) = Constant[7] : -# 436| r436_2(glval) = VariableAddress[x] : -# 436| m436_3(int) = Store : &:r436_2, r436_1 -#-----| Goto -> Block 3 - -# 439| Block 3 -# 439| r439_1(glval) = VariableAddress[a] : -# 439| r439_2(bool) = Load : &:r439_1, m433_5 -# 439| v439_3(void) = ConditionalBranch : r439_2 -#-----| False -> Block 4 -#-----| True -> Block 5 - -# 439| Block 4 -# 439| r439_4(glval) = VariableAddress[b] : -# 439| r439_5(bool) = Load : &:r439_4, m433_7 -# 439| v439_6(void) = ConditionalBranch : r439_5 -#-----| False -> Block 6 -#-----| True -> Block 5 - -# 440| Block 5 -# 440| r440_1(int) = Constant[1] : -# 440| r440_2(glval) = VariableAddress[x] : -# 440| m440_3(int) = Store : &:r440_2, r440_1 -#-----| Goto -> Block 7 - -# 443| Block 6 -# 443| r443_1(int) = Constant[5] : -# 443| r443_2(glval) = VariableAddress[x] : -# 443| m443_3(int) = Store : &:r443_2, r443_1 -#-----| Goto -> Block 7 - -# 445| Block 7 -# 445| v445_1(void) = NoOp : -# 433| v433_8(void) = ReturnVoid : -# 433| v433_9(void) = UnmodeledUse : mu* -# 433| v433_10(void) = AliasedUse : ~m433_2 -# 433| v433_11(void) = ExitFunction : - -# 447| void LogicalAnd(bool, bool) -# 447| Block 0 -# 447| v447_1(void) = EnterFunction : -# 447| m447_2(unknown) = AliasedDefinition : -# 447| mu447_3(unknown) = UnmodeledDefinition : -# 447| r447_4(glval) = VariableAddress[a] : -# 447| m447_5(bool) = InitializeParameter[a] : &:r447_4 -# 447| r447_6(glval) = VariableAddress[b] : -# 447| m447_7(bool) = InitializeParameter[b] : &:r447_6 -# 448| r448_1(glval) = VariableAddress[x] : -# 448| m448_2(int) = Uninitialized[x] : &:r448_1 -# 449| r449_1(glval) = VariableAddress[a] : -# 449| r449_2(bool) = Load : &:r449_1, m447_5 -# 449| v449_3(void) = ConditionalBranch : r449_2 -#-----| False -> Block 3 -#-----| True -> Block 1 - -# 449| Block 1 -# 449| r449_4(glval) = VariableAddress[b] : -# 449| r449_5(bool) = Load : &:r449_4, m447_7 -# 449| v449_6(void) = ConditionalBranch : r449_5 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 450| Block 2 -# 450| r450_1(int) = Constant[7] : -# 450| r450_2(glval) = VariableAddress[x] : -# 450| m450_3(int) = Store : &:r450_2, r450_1 -#-----| Goto -> Block 3 - -# 453| Block 3 -# 453| r453_1(glval) = VariableAddress[a] : -# 453| r453_2(bool) = Load : &:r453_1, m447_5 -# 453| v453_3(void) = ConditionalBranch : r453_2 -#-----| False -> Block 6 -#-----| True -> Block 4 - -# 453| Block 4 -# 453| r453_4(glval) = VariableAddress[b] : -# 453| r453_5(bool) = Load : &:r453_4, m447_7 -# 453| v453_6(void) = ConditionalBranch : r453_5 -#-----| False -> Block 6 -#-----| True -> Block 5 - -# 454| Block 5 -# 454| r454_1(int) = Constant[1] : -# 454| r454_2(glval) = VariableAddress[x] : -# 454| m454_3(int) = Store : &:r454_2, r454_1 -#-----| Goto -> Block 7 - -# 457| Block 6 -# 457| r457_1(int) = Constant[5] : -# 457| r457_2(glval) = VariableAddress[x] : -# 457| m457_3(int) = Store : &:r457_2, r457_1 -#-----| Goto -> Block 7 - -# 459| Block 7 -# 459| v459_1(void) = NoOp : -# 447| v447_8(void) = ReturnVoid : -# 447| v447_9(void) = UnmodeledUse : mu* -# 447| v447_10(void) = AliasedUse : ~m447_2 -# 447| v447_11(void) = ExitFunction : - -# 461| void LogicalNot(bool, bool) -# 461| Block 0 -# 461| v461_1(void) = EnterFunction : -# 461| m461_2(unknown) = AliasedDefinition : -# 461| mu461_3(unknown) = UnmodeledDefinition : -# 461| r461_4(glval) = VariableAddress[a] : -# 461| m461_5(bool) = InitializeParameter[a] : &:r461_4 -# 461| r461_6(glval) = VariableAddress[b] : -# 461| m461_7(bool) = InitializeParameter[b] : &:r461_6 -# 462| r462_1(glval) = VariableAddress[x] : -# 462| m462_2(int) = Uninitialized[x] : &:r462_1 -# 463| r463_1(glval) = VariableAddress[a] : -# 463| r463_2(bool) = Load : &:r463_1, m461_5 -# 463| v463_3(void) = ConditionalBranch : r463_2 -#-----| False -> Block 1 -#-----| True -> Block 2 - -# 464| Block 1 -# 464| r464_1(int) = Constant[1] : -# 464| r464_2(glval) = VariableAddress[x] : -# 464| m464_3(int) = Store : &:r464_2, r464_1 -#-----| Goto -> Block 2 - -# 467| Block 2 -# 467| r467_1(glval) = VariableAddress[a] : -# 467| r467_2(bool) = Load : &:r467_1, m461_5 -# 467| v467_3(void) = ConditionalBranch : r467_2 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 467| Block 3 -# 467| r467_4(glval) = VariableAddress[b] : -# 467| r467_5(bool) = Load : &:r467_4, m461_7 -# 467| v467_6(void) = ConditionalBranch : r467_5 -#-----| False -> Block 4 -#-----| True -> Block 5 - -# 468| Block 4 -# 468| r468_1(int) = Constant[2] : -# 468| r468_2(glval) = VariableAddress[x] : -# 468| m468_3(int) = Store : &:r468_2, r468_1 -#-----| Goto -> Block 6 - -# 471| Block 5 -# 471| r471_1(int) = Constant[3] : -# 471| r471_2(glval) = VariableAddress[x] : -# 471| m471_3(int) = Store : &:r471_2, r471_1 -#-----| Goto -> Block 6 - -# 473| Block 6 -# 473| v473_1(void) = NoOp : -# 461| v461_8(void) = ReturnVoid : -# 461| v461_9(void) = UnmodeledUse : mu* -# 461| v461_10(void) = AliasedUse : ~m461_2 -# 461| v461_11(void) = ExitFunction : - -# 475| void ConditionValues(bool, bool) -# 475| Block 0 -# 475| v475_1(void) = EnterFunction : -# 475| m475_2(unknown) = AliasedDefinition : -# 475| mu475_3(unknown) = UnmodeledDefinition : -# 475| r475_4(glval) = VariableAddress[a] : -# 475| m475_5(bool) = InitializeParameter[a] : &:r475_4 -# 475| r475_6(glval) = VariableAddress[b] : -# 475| m475_7(bool) = InitializeParameter[b] : &:r475_6 -# 476| r476_1(glval) = VariableAddress[x] : -# 476| m476_2(bool) = Uninitialized[x] : &:r476_1 -# 477| r477_1(glval) = VariableAddress[a] : -# 477| r477_2(bool) = Load : &:r477_1, m475_5 -# 477| v477_3(void) = ConditionalBranch : r477_2 -#-----| False -> Block 10 -#-----| True -> Block 1 - -# 477| Block 1 -# 477| r477_4(glval) = VariableAddress[b] : -# 477| r477_5(bool) = Load : &:r477_4, m475_7 -# 477| v477_6(void) = ConditionalBranch : r477_5 -#-----| False -> Block 10 -#-----| True -> Block 12 - -# 478| Block 2 -# 478| r478_1(glval) = VariableAddress[#temp478:9] : -# 478| r478_2(bool) = Constant[0] : -# 478| m478_3(bool) = Store : &:r478_1, r478_2 -#-----| Goto -> Block 3 - -# 478| Block 3 -# 478| m478_4(bool) = Phi : from 2:m478_3, from 4:m478_11 -# 478| r478_5(glval) = VariableAddress[#temp478:9] : -# 478| r478_6(bool) = Load : &:r478_5, m478_4 -# 478| r478_7(glval) = VariableAddress[x] : -# 478| m478_8(bool) = Store : &:r478_7, r478_6 -# 479| r479_1(glval) = VariableAddress[a] : -# 479| r479_2(bool) = Load : &:r479_1, m475_5 -# 479| v479_3(void) = ConditionalBranch : r479_2 -#-----| False -> Block 9 -#-----| True -> Block 8 - -# 478| Block 4 -# 478| r478_9(glval) = VariableAddress[#temp478:9] : -# 478| r478_10(bool) = Constant[1] : -# 478| m478_11(bool) = Store : &:r478_9, r478_10 -#-----| Goto -> Block 3 - -# 478| Block 5 -# 478| r478_12(glval) = VariableAddress[b] : -# 478| r478_13(bool) = Load : &:r478_12, m475_7 -# 478| v478_14(void) = ConditionalBranch : r478_13 -#-----| False -> Block 2 -#-----| True -> Block 4 - -# 479| Block 6 -# 479| r479_4(glval) = VariableAddress[#temp479:11] : -# 479| r479_5(bool) = Constant[0] : -# 479| m479_6(bool) = Store : &:r479_4, r479_5 -#-----| Goto -> Block 7 - -# 479| Block 7 -# 479| m479_7(bool) = Phi : from 6:m479_6, from 8:m479_15 -# 479| r479_8(glval) = VariableAddress[#temp479:11] : -# 479| r479_9(bool) = Load : &:r479_8, m479_7 -# 479| r479_10(bool) = LogicalNot : r479_9 -# 479| r479_11(glval) = VariableAddress[x] : -# 479| m479_12(bool) = Store : &:r479_11, r479_10 -# 480| v480_1(void) = NoOp : -# 475| v475_8(void) = ReturnVoid : -# 475| v475_9(void) = UnmodeledUse : mu* -# 475| v475_10(void) = AliasedUse : ~m475_2 -# 475| v475_11(void) = ExitFunction : - -# 479| Block 8 -# 479| r479_13(glval) = VariableAddress[#temp479:11] : -# 479| r479_14(bool) = Constant[1] : -# 479| m479_15(bool) = Store : &:r479_13, r479_14 -#-----| Goto -> Block 7 - -# 479| Block 9 -# 479| r479_16(glval) = VariableAddress[b] : -# 479| r479_17(bool) = Load : &:r479_16, m475_7 -# 479| v479_18(void) = ConditionalBranch : r479_17 -#-----| False -> Block 6 -#-----| True -> Block 8 - -# 477| Block 10 -# 477| r477_7(glval) = VariableAddress[#temp477:9] : -# 477| r477_8(bool) = Constant[0] : -# 477| m477_9(bool) = Store : &:r477_7, r477_8 -#-----| Goto -> Block 11 - -# 477| Block 11 -# 477| m477_10(bool) = Phi : from 10:m477_9, from 12:m477_17 -# 477| r477_11(glval) = VariableAddress[#temp477:9] : -# 477| r477_12(bool) = Load : &:r477_11, m477_10 -# 477| r477_13(glval) = VariableAddress[x] : -# 477| m477_14(bool) = Store : &:r477_13, r477_12 -# 478| r478_15(glval) = VariableAddress[a] : -# 478| r478_16(bool) = Load : &:r478_15, m475_5 -# 478| v478_17(void) = ConditionalBranch : r478_16 -#-----| False -> Block 5 -#-----| True -> Block 4 - -# 477| Block 12 -# 477| r477_15(glval) = VariableAddress[#temp477:9] : -# 477| r477_16(bool) = Constant[1] : -# 477| m477_17(bool) = Store : &:r477_15, r477_16 -#-----| Goto -> Block 11 - -# 482| void Conditional(bool, int, int) -# 482| Block 0 -# 482| v482_1(void) = EnterFunction : -# 482| m482_2(unknown) = AliasedDefinition : -# 482| mu482_3(unknown) = UnmodeledDefinition : -# 482| r482_4(glval) = VariableAddress[a] : -# 482| m482_5(bool) = InitializeParameter[a] : &:r482_4 -# 482| r482_6(glval) = VariableAddress[x] : -# 482| m482_7(int) = InitializeParameter[x] : &:r482_6 -# 482| r482_8(glval) = VariableAddress[y] : -# 482| m482_9(int) = InitializeParameter[y] : &:r482_8 -# 483| r483_1(glval) = VariableAddress[z] : -# 483| r483_2(glval) = VariableAddress[a] : -# 483| r483_3(bool) = Load : &:r483_2, m482_5 -# 483| v483_4(void) = ConditionalBranch : r483_3 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 483| Block 1 -# 483| r483_5(glval) = VariableAddress[x] : -# 483| r483_6(int) = Load : &:r483_5, m482_7 -# 483| r483_7(glval) = VariableAddress[#temp483:13] : -# 483| m483_8(int) = Store : &:r483_7, r483_6 -#-----| Goto -> Block 3 - -# 483| Block 2 -# 483| r483_9(glval) = VariableAddress[y] : -# 483| r483_10(int) = Load : &:r483_9, m482_9 -# 483| r483_11(glval) = VariableAddress[#temp483:13] : -# 483| m483_12(int) = Store : &:r483_11, r483_10 -#-----| Goto -> Block 3 - -# 483| Block 3 -# 483| m483_13(int) = Phi : from 1:m483_8, from 2:m483_12 -# 483| r483_14(glval) = VariableAddress[#temp483:13] : -# 483| r483_15(int) = Load : &:r483_14, m483_13 -# 483| m483_16(int) = Store : &:r483_1, r483_15 -# 484| v484_1(void) = NoOp : -# 482| v482_10(void) = ReturnVoid : -# 482| v482_11(void) = UnmodeledUse : mu* -# 482| v482_12(void) = AliasedUse : ~m482_2 -# 482| v482_13(void) = ExitFunction : - -# 486| void Conditional_LValue(bool) -# 486| Block 0 -# 486| v486_1(void) = EnterFunction : -# 486| m486_2(unknown) = AliasedDefinition : -# 486| mu486_3(unknown) = UnmodeledDefinition : -# 486| r486_4(glval) = VariableAddress[a] : -# 486| m486_5(bool) = InitializeParameter[a] : &:r486_4 -# 487| r487_1(glval) = VariableAddress[x] : -# 487| m487_2(int) = Uninitialized[x] : &:r487_1 -# 488| r488_1(glval) = VariableAddress[y] : -# 488| m488_2(int) = Uninitialized[y] : &:r488_1 -# 489| r489_1(int) = Constant[5] : -# 489| r489_2(glval) = VariableAddress[a] : -# 489| r489_3(bool) = Load : &:r489_2, m486_5 -# 489| v489_4(void) = ConditionalBranch : r489_3 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 489| Block 1 -# 489| m489_5(glval) = Phi : from 2:m489_12, from 3:m489_15 -# 489| r489_6(glval) = VariableAddress[#temp489:6] : -# 489| r489_7(glval) = Load : &:r489_6, m489_5 -# 489| m489_8(int) = Store : &:r489_7, r489_1 -# 489| m489_9(unknown) = Chi : total:m486_2, partial:m489_8 -# 490| v490_1(void) = NoOp : -# 486| v486_6(void) = ReturnVoid : -# 486| v486_7(void) = UnmodeledUse : mu* -# 486| v486_8(void) = AliasedUse : ~m489_9 -# 486| v486_9(void) = ExitFunction : - -# 489| Block 2 -# 489| r489_10(glval) = VariableAddress[x] : -# 489| r489_11(glval) = VariableAddress[#temp489:6] : -# 489| m489_12(glval) = Store : &:r489_11, r489_10 -#-----| Goto -> Block 1 - -# 489| Block 3 -# 489| r489_13(glval) = VariableAddress[y] : -# 489| r489_14(glval) = VariableAddress[#temp489:6] : -# 489| m489_15(glval) = Store : &:r489_14, r489_13 -#-----| Goto -> Block 1 - -# 492| void Conditional_Void(bool) -# 492| Block 0 -# 492| v492_1(void) = EnterFunction : -# 492| m492_2(unknown) = AliasedDefinition : -# 492| mu492_3(unknown) = UnmodeledDefinition : -# 492| r492_4(glval) = VariableAddress[a] : -# 492| m492_5(bool) = InitializeParameter[a] : &:r492_4 -# 493| r493_1(glval) = VariableAddress[a] : -# 493| r493_2(bool) = Load : &:r493_1, m492_5 -# 493| v493_3(void) = ConditionalBranch : r493_2 -#-----| False -> Block 1 -#-----| True -> Block 3 - -# 493| Block 1 -# 493| r493_4(glval) = FunctionAddress[VoidFunc] : -# 493| v493_5(void) = Call : func:r493_4 -# 493| m493_6(unknown) = ^CallSideEffect : ~m492_2 -# 493| m493_7(unknown) = Chi : total:m492_2, partial:m493_6 -#-----| Goto -> Block 2 - -# 494| Block 2 -# 494| m494_1(unknown) = Phi : from 1:~m493_7, from 3:~m493_11 -# 494| v494_2(void) = NoOp : -# 492| v492_6(void) = ReturnVoid : -# 492| v492_7(void) = UnmodeledUse : mu* -# 492| v492_8(void) = AliasedUse : ~m494_1 -# 492| v492_9(void) = ExitFunction : - -# 493| Block 3 -# 493| r493_8(glval) = FunctionAddress[VoidFunc] : -# 493| v493_9(void) = Call : func:r493_8 -# 493| m493_10(unknown) = ^CallSideEffect : ~m492_2 -# 493| m493_11(unknown) = Chi : total:m492_2, partial:m493_10 -#-----| Goto -> Block 2 - -# 496| void Nullptr() -# 496| Block 0 -# 496| v496_1(void) = EnterFunction : -# 496| m496_2(unknown) = AliasedDefinition : -# 496| mu496_3(unknown) = UnmodeledDefinition : -# 497| r497_1(glval) = VariableAddress[p] : -# 497| r497_2(int *) = Constant[0] : -# 497| m497_3(int *) = Store : &:r497_1, r497_2 -# 498| r498_1(glval) = VariableAddress[q] : -# 498| r498_2(int *) = Constant[0] : -# 498| m498_3(int *) = Store : &:r498_1, r498_2 -# 499| r499_1(int *) = Constant[0] : -# 499| r499_2(glval) = VariableAddress[p] : -# 499| m499_3(int *) = Store : &:r499_2, r499_1 -# 500| r500_1(int *) = Constant[0] : -# 500| r500_2(glval) = VariableAddress[q] : -# 500| m500_3(int *) = Store : &:r500_2, r500_1 -# 501| v501_1(void) = NoOp : -# 496| v496_4(void) = ReturnVoid : -# 496| v496_5(void) = UnmodeledUse : mu* -# 496| v496_6(void) = AliasedUse : ~m496_2 -# 496| v496_7(void) = ExitFunction : - -# 503| void InitList(int, float) -# 503| Block 0 -# 503| v503_1(void) = EnterFunction : -# 503| m503_2(unknown) = AliasedDefinition : -# 503| mu503_3(unknown) = UnmodeledDefinition : -# 503| r503_4(glval) = VariableAddress[x] : -# 503| m503_5(int) = InitializeParameter[x] : &:r503_4 -# 503| r503_6(glval) = VariableAddress[f] : -# 503| m503_7(float) = InitializeParameter[f] : &:r503_6 -# 504| r504_1(glval) = VariableAddress[pt1] : -# 504| m504_2(Point) = Uninitialized[pt1] : &:r504_1 -# 504| r504_3(glval) = FieldAddress[x] : r504_1 -# 504| r504_4(glval) = VariableAddress[x] : -# 504| r504_5(int) = Load : &:r504_4, m503_5 -# 504| m504_6(int) = Store : &:r504_3, r504_5 -# 504| m504_7(Point) = Chi : total:m504_2, partial:m504_6 -# 504| r504_8(glval) = FieldAddress[y] : r504_1 -# 504| r504_9(glval) = VariableAddress[f] : -# 504| r504_10(float) = Load : &:r504_9, m503_7 -# 504| r504_11(int) = Convert : r504_10 -# 504| m504_12(int) = Store : &:r504_8, r504_11 -# 504| m504_13(Point) = Chi : total:m504_7, partial:m504_12 -# 505| r505_1(glval) = VariableAddress[pt2] : -# 505| m505_2(Point) = Uninitialized[pt2] : &:r505_1 -# 505| r505_3(glval) = FieldAddress[x] : r505_1 -# 505| r505_4(glval) = VariableAddress[x] : -# 505| r505_5(int) = Load : &:r505_4, m503_5 -# 505| m505_6(int) = Store : &:r505_3, r505_5 -# 505| m505_7(Point) = Chi : total:m505_2, partial:m505_6 -# 505| r505_8(glval) = FieldAddress[y] : r505_1 -# 505| r505_9(int) = Constant[0] : -# 505| m505_10(int) = Store : &:r505_8, r505_9 -# 505| m505_11(Point) = Chi : total:m505_7, partial:m505_10 -# 506| r506_1(glval) = VariableAddress[pt3] : -# 506| m506_2(Point) = Uninitialized[pt3] : &:r506_1 -# 506| r506_3(glval) = FieldAddress[x] : r506_1 -# 506| r506_4(int) = Constant[0] : -# 506| m506_5(int) = Store : &:r506_3, r506_4 -# 506| m506_6(Point) = Chi : total:m506_2, partial:m506_5 -# 506| r506_7(glval) = FieldAddress[y] : r506_1 -# 506| r506_8(int) = Constant[0] : -# 506| m506_9(int) = Store : &:r506_7, r506_8 -# 506| m506_10(Point) = Chi : total:m506_6, partial:m506_9 -# 508| r508_1(glval) = VariableAddress[x1] : -# 508| r508_2(int) = Constant[1] : -# 508| m508_3(int) = Store : &:r508_1, r508_2 -# 509| r509_1(glval) = VariableAddress[x2] : -# 509| r509_2(int) = Constant[0] : -# 509| m509_3(int) = Store : &:r509_1, r509_2 -# 510| v510_1(void) = NoOp : -# 503| v503_8(void) = ReturnVoid : -# 503| v503_9(void) = UnmodeledUse : mu* -# 503| v503_10(void) = AliasedUse : ~m503_2 -# 503| v503_11(void) = ExitFunction : - -# 512| void NestedInitList(int, float) -# 512| Block 0 -# 512| v512_1(void) = EnterFunction : -# 512| m512_2(unknown) = AliasedDefinition : -# 512| mu512_3(unknown) = UnmodeledDefinition : -# 512| r512_4(glval) = VariableAddress[x] : -# 512| m512_5(int) = InitializeParameter[x] : &:r512_4 -# 512| r512_6(glval) = VariableAddress[f] : -# 512| m512_7(float) = InitializeParameter[f] : &:r512_6 -# 513| r513_1(glval) = VariableAddress[r1] : -# 513| m513_2(Rect) = Uninitialized[r1] : &:r513_1 -# 513| r513_3(glval) = FieldAddress[topLeft] : r513_1 -# 513| r513_4(Point) = Constant[0] : -# 513| m513_5(Point) = Store : &:r513_3, r513_4 -# 513| m513_6(Rect) = Chi : total:m513_2, partial:m513_5 -# 513| r513_7(glval) = FieldAddress[bottomRight] : r513_1 -# 513| r513_8(Point) = Constant[0] : -# 513| m513_9(Point) = Store : &:r513_7, r513_8 -# 513| m513_10(Rect) = Chi : total:m513_6, partial:m513_9 -# 514| r514_1(glval) = VariableAddress[r2] : -# 514| m514_2(Rect) = Uninitialized[r2] : &:r514_1 -# 514| r514_3(glval) = FieldAddress[topLeft] : r514_1 -# 514| r514_4(glval) = FieldAddress[x] : r514_3 -# 514| r514_5(glval) = VariableAddress[x] : -# 514| r514_6(int) = Load : &:r514_5, m512_5 -# 514| m514_7(int) = Store : &:r514_4, r514_6 -# 514| m514_8(Rect) = Chi : total:m514_2, partial:m514_7 -# 514| r514_9(glval) = FieldAddress[y] : r514_3 -# 514| r514_10(glval) = VariableAddress[f] : -# 514| r514_11(float) = Load : &:r514_10, m512_7 -# 514| r514_12(int) = Convert : r514_11 -# 514| m514_13(int) = Store : &:r514_9, r514_12 -# 514| m514_14(Rect) = Chi : total:m514_8, partial:m514_13 -# 514| r514_15(glval) = FieldAddress[bottomRight] : r514_1 -# 514| r514_16(Point) = Constant[0] : -# 514| m514_17(Point) = Store : &:r514_15, r514_16 -# 514| m514_18(Rect) = Chi : total:m514_14, partial:m514_17 -# 515| r515_1(glval) = VariableAddress[r3] : -# 515| m515_2(Rect) = Uninitialized[r3] : &:r515_1 -# 515| r515_3(glval) = FieldAddress[topLeft] : r515_1 -# 515| r515_4(glval) = FieldAddress[x] : r515_3 -# 515| r515_5(glval) = VariableAddress[x] : -# 515| r515_6(int) = Load : &:r515_5, m512_5 -# 515| m515_7(int) = Store : &:r515_4, r515_6 -# 515| m515_8(Rect) = Chi : total:m515_2, partial:m515_7 -# 515| r515_9(glval) = FieldAddress[y] : r515_3 -# 515| r515_10(glval) = VariableAddress[f] : -# 515| r515_11(float) = Load : &:r515_10, m512_7 -# 515| r515_12(int) = Convert : r515_11 -# 515| m515_13(int) = Store : &:r515_9, r515_12 -# 515| m515_14(Rect) = Chi : total:m515_8, partial:m515_13 -# 515| r515_15(glval) = FieldAddress[bottomRight] : r515_1 -# 515| r515_16(glval) = FieldAddress[x] : r515_15 -# 515| r515_17(glval) = VariableAddress[x] : -# 515| r515_18(int) = Load : &:r515_17, m512_5 -# 515| m515_19(int) = Store : &:r515_16, r515_18 -# 515| m515_20(Rect) = Chi : total:m515_14, partial:m515_19 -# 515| r515_21(glval) = FieldAddress[y] : r515_15 -# 515| r515_22(glval) = VariableAddress[f] : -# 515| r515_23(float) = Load : &:r515_22, m512_7 -# 515| r515_24(int) = Convert : r515_23 -# 515| m515_25(int) = Store : &:r515_21, r515_24 -# 515| m515_26(Rect) = Chi : total:m515_20, partial:m515_25 -# 516| r516_1(glval) = VariableAddress[r4] : -# 516| m516_2(Rect) = Uninitialized[r4] : &:r516_1 -# 516| r516_3(glval) = FieldAddress[topLeft] : r516_1 -# 516| r516_4(glval) = FieldAddress[x] : r516_3 -# 516| r516_5(glval) = VariableAddress[x] : -# 516| r516_6(int) = Load : &:r516_5, m512_5 -# 516| m516_7(int) = Store : &:r516_4, r516_6 -# 516| m516_8(Rect) = Chi : total:m516_2, partial:m516_7 -# 516| r516_9(glval) = FieldAddress[y] : r516_3 -# 516| r516_10(int) = Constant[0] : -# 516| m516_11(int) = Store : &:r516_9, r516_10 -# 516| m516_12(Rect) = Chi : total:m516_8, partial:m516_11 -# 516| r516_13(glval) = FieldAddress[bottomRight] : r516_1 -# 516| r516_14(glval) = FieldAddress[x] : r516_13 -# 516| r516_15(glval) = VariableAddress[x] : -# 516| r516_16(int) = Load : &:r516_15, m512_5 -# 516| m516_17(int) = Store : &:r516_14, r516_16 -# 516| m516_18(Rect) = Chi : total:m516_12, partial:m516_17 -# 516| r516_19(glval) = FieldAddress[y] : r516_13 -# 516| r516_20(int) = Constant[0] : -# 516| m516_21(int) = Store : &:r516_19, r516_20 -# 516| m516_22(Rect) = Chi : total:m516_18, partial:m516_21 -# 517| v517_1(void) = NoOp : -# 512| v512_8(void) = ReturnVoid : -# 512| v512_9(void) = UnmodeledUse : mu* -# 512| v512_10(void) = AliasedUse : ~m512_2 -# 512| v512_11(void) = ExitFunction : - -# 519| void ArrayInit(int, float) -# 519| Block 0 -# 519| v519_1(void) = EnterFunction : -# 519| m519_2(unknown) = AliasedDefinition : -# 519| mu519_3(unknown) = UnmodeledDefinition : -# 519| r519_4(glval) = VariableAddress[x] : -# 519| m519_5(int) = InitializeParameter[x] : &:r519_4 -# 519| r519_6(glval) = VariableAddress[f] : -# 519| m519_7(float) = InitializeParameter[f] : &:r519_6 -# 520| r520_1(glval) = VariableAddress[a1] : -# 520| m520_2(int[3]) = Uninitialized[a1] : &:r520_1 -# 520| r520_3(int) = Constant[0] : -# 520| r520_4(glval) = PointerAdd[4] : r520_1, r520_3 -# 520| r520_5(unknown[12]) = Constant[0] : -# 520| m520_6(unknown[12]) = Store : &:r520_4, r520_5 -# 521| r521_1(glval) = VariableAddress[a2] : -# 521| m521_2(int[3]) = Uninitialized[a2] : &:r521_1 -# 521| r521_3(int) = Constant[0] : -# 521| r521_4(glval) = PointerAdd[4] : r521_1, r521_3 -# 521| r521_5(glval) = VariableAddress[x] : -# 521| r521_6(int) = Load : &:r521_5, m519_5 -# 521| m521_7(int) = Store : &:r521_4, r521_6 -# 521| m521_8(int[3]) = Chi : total:m521_2, partial:m521_7 -# 521| r521_9(int) = Constant[1] : -# 521| r521_10(glval) = PointerAdd[4] : r521_1, r521_9 -# 521| r521_11(glval) = VariableAddress[f] : -# 521| r521_12(float) = Load : &:r521_11, m519_7 -# 521| r521_13(int) = Convert : r521_12 -# 521| m521_14(int) = Store : &:r521_10, r521_13 -# 521| m521_15(int[3]) = Chi : total:m521_8, partial:m521_14 -# 521| r521_16(int) = Constant[2] : -# 521| r521_17(glval) = PointerAdd[4] : r521_1, r521_16 -# 521| r521_18(int) = Constant[0] : -# 521| m521_19(int) = Store : &:r521_17, r521_18 -# 521| m521_20(int[3]) = Chi : total:m521_15, partial:m521_19 -# 522| r522_1(glval) = VariableAddress[a3] : -# 522| m522_2(int[3]) = Uninitialized[a3] : &:r522_1 -# 522| r522_3(int) = Constant[0] : -# 522| r522_4(glval) = PointerAdd[4] : r522_1, r522_3 -# 522| r522_5(glval) = VariableAddress[x] : -# 522| r522_6(int) = Load : &:r522_5, m519_5 -# 522| m522_7(int) = Store : &:r522_4, r522_6 -# 522| m522_8(int[3]) = Chi : total:m522_2, partial:m522_7 -# 522| r522_9(int) = Constant[1] : -# 522| r522_10(glval) = PointerAdd[4] : r522_1, r522_9 -# 522| r522_11(unknown[8]) = Constant[0] : -# 522| m522_12(unknown[8]) = Store : &:r522_10, r522_11 -# 522| m522_13(int[3]) = Chi : total:m522_8, partial:m522_12 -# 523| v523_1(void) = NoOp : -# 519| v519_8(void) = ReturnVoid : -# 519| v519_9(void) = UnmodeledUse : mu* -# 519| v519_10(void) = AliasedUse : ~m519_2 -# 519| v519_11(void) = ExitFunction : - -# 530| void UnionInit(int, float) -# 530| Block 0 -# 530| v530_1(void) = EnterFunction : -# 530| m530_2(unknown) = AliasedDefinition : -# 530| mu530_3(unknown) = UnmodeledDefinition : -# 530| r530_4(glval) = VariableAddress[x] : -# 530| m530_5(int) = InitializeParameter[x] : &:r530_4 -# 530| r530_6(glval) = VariableAddress[f] : -# 530| m530_7(float) = InitializeParameter[f] : &:r530_6 -# 531| r531_1(glval) = VariableAddress[u1] : -# 531| m531_2(U) = Uninitialized[u1] : &:r531_1 -# 531| r531_3(glval) = FieldAddress[d] : r531_1 -# 531| r531_4(glval) = VariableAddress[f] : -# 531| r531_5(float) = Load : &:r531_4, m530_7 -# 531| r531_6(double) = Convert : r531_5 -# 531| m531_7(double) = Store : &:r531_3, r531_6 -# 533| v533_1(void) = NoOp : -# 530| v530_8(void) = ReturnVoid : -# 530| v530_9(void) = UnmodeledUse : mu* -# 530| v530_10(void) = AliasedUse : ~m530_2 -# 530| v530_11(void) = ExitFunction : - -# 535| void EarlyReturn(int, int) -# 535| Block 0 -# 535| v535_1(void) = EnterFunction : -# 535| m535_2(unknown) = AliasedDefinition : -# 535| mu535_3(unknown) = UnmodeledDefinition : -# 535| r535_4(glval) = VariableAddress[x] : -# 535| m535_5(int) = InitializeParameter[x] : &:r535_4 -# 535| r535_6(glval) = VariableAddress[y] : -# 535| m535_7(int) = InitializeParameter[y] : &:r535_6 -# 536| r536_1(glval) = VariableAddress[x] : -# 536| r536_2(int) = Load : &:r536_1, m535_5 -# 536| r536_3(glval) = VariableAddress[y] : -# 536| r536_4(int) = Load : &:r536_3, m535_7 -# 536| r536_5(bool) = CompareLT : r536_2, r536_4 -# 536| v536_6(void) = ConditionalBranch : r536_5 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 535| Block 1 -# 535| v535_8(void) = ReturnVoid : -# 535| v535_9(void) = UnmodeledUse : mu* -# 535| v535_10(void) = AliasedUse : ~m535_2 -# 535| v535_11(void) = ExitFunction : - -# 537| Block 2 -# 537| v537_1(void) = NoOp : -#-----| Goto -> Block 1 - -# 540| Block 3 -# 540| r540_1(glval) = VariableAddress[x] : -# 540| r540_2(int) = Load : &:r540_1, m535_5 -# 540| r540_3(glval) = VariableAddress[y] : -# 540| m540_4(int) = Store : &:r540_3, r540_2 -# 541| v541_1(void) = NoOp : -#-----| Goto -> Block 1 - -# 543| int EarlyReturnValue(int, int) -# 543| Block 0 -# 543| v543_1(void) = EnterFunction : -# 543| m543_2(unknown) = AliasedDefinition : -# 543| mu543_3(unknown) = UnmodeledDefinition : -# 543| r543_4(glval) = VariableAddress[x] : -# 543| m543_5(int) = InitializeParameter[x] : &:r543_4 -# 543| r543_6(glval) = VariableAddress[y] : -# 543| m543_7(int) = InitializeParameter[y] : &:r543_6 -# 544| r544_1(glval) = VariableAddress[x] : -# 544| r544_2(int) = Load : &:r544_1, m543_5 -# 544| r544_3(glval) = VariableAddress[y] : -# 544| r544_4(int) = Load : &:r544_3, m543_7 -# 544| r544_5(bool) = CompareLT : r544_2, r544_4 -# 544| v544_6(void) = ConditionalBranch : r544_5 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 543| Block 1 -# 543| m543_8(int) = Phi : from 2:m545_4, from 3:m548_7 -# 543| r543_9(glval) = VariableAddress[#return] : -# 543| v543_10(void) = ReturnValue : &:r543_9, m543_8 -# 543| v543_11(void) = UnmodeledUse : mu* -# 543| v543_12(void) = AliasedUse : ~m543_2 -# 543| v543_13(void) = ExitFunction : - -# 545| Block 2 -# 545| r545_1(glval) = VariableAddress[#return] : -# 545| r545_2(glval) = VariableAddress[x] : -# 545| r545_3(int) = Load : &:r545_2, m543_5 -# 545| m545_4(int) = Store : &:r545_1, r545_3 -#-----| Goto -> Block 1 - -# 548| Block 3 -# 548| r548_1(glval) = VariableAddress[#return] : -# 548| r548_2(glval) = VariableAddress[x] : -# 548| r548_3(int) = Load : &:r548_2, m543_5 -# 548| r548_4(glval) = VariableAddress[y] : -# 548| r548_5(int) = Load : &:r548_4, m543_7 -# 548| r548_6(int) = Add : r548_3, r548_5 -# 548| m548_7(int) = Store : &:r548_1, r548_6 -#-----| Goto -> Block 1 - -# 551| int CallViaFuncPtr(int(*)(int)) -# 551| Block 0 -# 551| v551_1(void) = EnterFunction : -# 551| m551_2(unknown) = AliasedDefinition : -# 551| mu551_3(unknown) = UnmodeledDefinition : -# 551| r551_4(glval<..(*)(..)>) = VariableAddress[pfn] : -# 551| m551_5(..(*)(..)) = InitializeParameter[pfn] : &:r551_4 -# 552| r552_1(glval) = VariableAddress[#return] : -# 552| r552_2(glval<..(*)(..)>) = VariableAddress[pfn] : -# 552| r552_3(..(*)(..)) = Load : &:r552_2, m551_5 -# 552| r552_4(int) = Constant[5] : -# 552| r552_5(int) = Call : func:r552_3, 0:r552_4 -# 552| m552_6(unknown) = ^CallSideEffect : ~m551_2 -# 552| m552_7(unknown) = Chi : total:m551_2, partial:m552_6 -# 552| m552_8(int) = Store : &:r552_1, r552_5 -# 551| r551_6(glval) = VariableAddress[#return] : -# 551| v551_7(void) = ReturnValue : &:r551_6, m552_8 -# 551| v551_8(void) = UnmodeledUse : mu* -# 551| v551_9(void) = AliasedUse : ~m552_7 -# 551| v551_10(void) = ExitFunction : - -# 560| int EnumSwitch(E) -# 560| Block 0 -# 560| v560_1(void) = EnterFunction : -# 560| m560_2(unknown) = AliasedDefinition : -# 560| mu560_3(unknown) = UnmodeledDefinition : -# 560| r560_4(glval) = VariableAddress[e] : -# 560| m560_5(E) = InitializeParameter[e] : &:r560_4 -# 561| r561_1(glval) = VariableAddress[e] : -# 561| r561_2(E) = Load : &:r561_1, m560_5 -# 561| r561_3(int) = Convert : r561_2 -# 561| v561_4(void) = Switch : r561_3 -#-----| Case[0] -> Block 4 -#-----| Case[1] -> Block 2 -#-----| Default -> Block 3 - -# 560| Block 1 -# 560| m560_6(int) = Phi : from 2:m565_3, from 3:m567_3, from 4:m563_3 -# 560| r560_7(glval) = VariableAddress[#return] : -# 560| v560_8(void) = ReturnValue : &:r560_7, m560_6 -# 560| v560_9(void) = UnmodeledUse : mu* -# 560| v560_10(void) = AliasedUse : ~m560_2 -# 560| v560_11(void) = ExitFunction : - -# 564| Block 2 -# 564| v564_1(void) = NoOp : -# 565| r565_1(glval) = VariableAddress[#return] : -# 565| r565_2(int) = Constant[1] : -# 565| m565_3(int) = Store : &:r565_1, r565_2 -#-----| Goto -> Block 1 - -# 566| Block 3 -# 566| v566_1(void) = NoOp : -# 567| r567_1(glval) = VariableAddress[#return] : -# 567| r567_2(int) = Constant[-1] : -# 567| m567_3(int) = Store : &:r567_1, r567_2 -#-----| Goto -> Block 1 - -# 562| Block 4 -# 562| v562_1(void) = NoOp : -# 563| r563_1(glval) = VariableAddress[#return] : -# 563| r563_2(int) = Constant[0] : -# 563| m563_3(int) = Store : &:r563_1, r563_2 -#-----| Goto -> Block 1 - -# 571| void InitArray() -# 571| Block 0 -# 571| v571_1(void) = EnterFunction : -# 571| m571_2(unknown) = AliasedDefinition : -# 571| mu571_3(unknown) = UnmodeledDefinition : -# 572| r572_1(glval) = VariableAddress[a_pad] : -# 572| r572_2(glval) = StringConstant[""] : -# 572| r572_3(char[32]) = Load : &:r572_2, ~m571_2 -# 572| m572_4(char[32]) = Store : &:r572_1, r572_3 -# 573| r573_1(glval) = VariableAddress[a_nopad] : -# 573| r573_2(glval) = StringConstant["foo"] : -# 573| r573_3(char[4]) = Load : &:r573_2, ~m571_2 -# 573| m573_4(char[4]) = Store : &:r573_1, r573_3 -# 574| r574_1(glval) = VariableAddress[a_infer] : -# 574| r574_2(glval) = StringConstant["blah"] : -# 574| r574_3(char[5]) = Load : &:r574_2, ~m571_2 -# 574| m574_4(char[5]) = Store : &:r574_1, r574_3 -# 575| r575_1(glval) = VariableAddress[b] : -# 575| m575_2(char[2]) = Uninitialized[b] : &:r575_1 -# 576| r576_1(glval) = VariableAddress[c] : -# 576| m576_2(char[2]) = Uninitialized[c] : &:r576_1 -# 576| r576_3(int) = Constant[0] : -# 576| r576_4(glval) = PointerAdd[1] : r576_1, r576_3 -# 576| r576_5(unknown[2]) = Constant[0] : -# 576| m576_6(unknown[2]) = Store : &:r576_4, r576_5 -# 577| r577_1(glval) = VariableAddress[d] : -# 577| m577_2(char[2]) = Uninitialized[d] : &:r577_1 -# 577| r577_3(int) = Constant[0] : -# 577| r577_4(glval) = PointerAdd[1] : r577_1, r577_3 -# 577| r577_5(char) = Constant[0] : -# 577| m577_6(char) = Store : &:r577_4, r577_5 -# 577| m577_7(char[2]) = Chi : total:m577_2, partial:m577_6 -# 577| r577_8(int) = Constant[1] : -# 577| r577_9(glval) = PointerAdd[1] : r577_1, r577_8 -# 577| r577_10(char) = Constant[0] : -# 577| m577_11(char) = Store : &:r577_9, r577_10 -# 577| m577_12(char[2]) = Chi : total:m577_7, partial:m577_11 -# 578| r578_1(glval) = VariableAddress[e] : -# 578| m578_2(char[2]) = Uninitialized[e] : &:r578_1 -# 578| r578_3(int) = Constant[0] : -# 578| r578_4(glval) = PointerAdd[1] : r578_1, r578_3 -# 578| r578_5(char) = Constant[0] : -# 578| m578_6(char) = Store : &:r578_4, r578_5 -# 578| m578_7(char[2]) = Chi : total:m578_2, partial:m578_6 -# 578| r578_8(int) = Constant[1] : -# 578| r578_9(glval) = PointerAdd[1] : r578_1, r578_8 -# 578| r578_10(char) = Constant[1] : -# 578| m578_11(char) = Store : &:r578_9, r578_10 -# 578| m578_12(char[2]) = Chi : total:m578_7, partial:m578_11 -# 579| r579_1(glval) = VariableAddress[f] : -# 579| m579_2(char[3]) = Uninitialized[f] : &:r579_1 -# 579| r579_3(int) = Constant[0] : -# 579| r579_4(glval) = PointerAdd[1] : r579_1, r579_3 -# 579| r579_5(char) = Constant[0] : -# 579| m579_6(char) = Store : &:r579_4, r579_5 -# 579| m579_7(char[3]) = Chi : total:m579_2, partial:m579_6 -# 579| r579_8(int) = Constant[1] : -# 579| r579_9(glval) = PointerAdd[1] : r579_1, r579_8 -# 579| r579_10(unknown[2]) = Constant[0] : -# 579| m579_11(unknown[2]) = Store : &:r579_9, r579_10 -# 579| m579_12(char[3]) = Chi : total:m579_7, partial:m579_11 -# 580| v580_1(void) = NoOp : -# 571| v571_4(void) = ReturnVoid : -# 571| v571_5(void) = UnmodeledUse : mu* -# 571| v571_6(void) = AliasedUse : ~m571_2 -# 571| v571_7(void) = ExitFunction : - -# 584| void VarArgs() -# 584| Block 0 -# 584| v584_1(void) = EnterFunction : -# 584| m584_2(unknown) = AliasedDefinition : -# 584| mu584_3(unknown) = UnmodeledDefinition : -# 585| r585_1(glval) = FunctionAddress[VarArgFunction] : -# 585| r585_2(glval) = StringConstant["%d %s"] : -# 585| r585_3(char *) = Convert : r585_2 -# 585| r585_4(int) = Constant[1] : -# 585| r585_5(glval) = StringConstant["string"] : -# 585| r585_6(char *) = Convert : r585_5 -# 585| v585_7(void) = Call : func:r585_1, 0:r585_3, 1:r585_4, 2:r585_6 -# 585| m585_8(unknown) = ^CallSideEffect : ~m584_2 -# 585| m585_9(unknown) = Chi : total:m584_2, partial:m585_8 -# 585| v585_10(void) = ^BufferReadSideEffect[0] : &:r585_3, ~m584_2 -# 585| v585_11(void) = ^BufferReadSideEffect[2] : &:r585_6, ~m584_2 -# 585| m585_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r585_3 -# 585| m585_13(unknown) = Chi : total:m585_9, partial:m585_12 -# 585| m585_14(unknown) = ^BufferMayWriteSideEffect[2] : &:r585_6 -# 585| m585_15(unknown) = Chi : total:m585_13, partial:m585_14 -# 586| v586_1(void) = NoOp : -# 584| v584_4(void) = ReturnVoid : -# 584| v584_5(void) = UnmodeledUse : mu* -# 584| v584_6(void) = AliasedUse : ~m585_15 -# 584| v584_7(void) = ExitFunction : - -# 590| void SetFuncPtr() -# 590| Block 0 -# 590| v590_1(void) = EnterFunction : -# 590| m590_2(unknown) = AliasedDefinition : -# 590| mu590_3(unknown) = UnmodeledDefinition : -# 591| r591_1(glval<..(*)(..)>) = VariableAddress[pfn] : -# 591| r591_2(..(*)(..)) = FunctionAddress[FuncPtrTarget] : -# 591| m591_3(..(*)(..)) = Store : &:r591_1, r591_2 -# 592| r592_1(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 592| r592_2(..(*)(..)) = CopyValue : r592_1 -# 592| r592_3(glval<..(*)(..)>) = VariableAddress[pfn] : -# 592| m592_4(..(*)(..)) = Store : &:r592_3, r592_2 -# 593| r593_1(..(*)(..)) = FunctionAddress[FuncPtrTarget] : -# 593| r593_2(..(*)(..)) = CopyValue : r593_1 -# 593| r593_3(glval<..(*)(..)>) = VariableAddress[pfn] : -# 593| m593_4(..(*)(..)) = Store : &:r593_3, r593_2 -# 594| r594_1(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 594| r594_2(..(*)(..)) = CopyValue : r594_1 -# 594| r594_3(..(*)(..)) = CopyValue : r594_2 -# 594| r594_4(..(*)(..)) = CopyValue : r594_3 -# 594| r594_5(..(*)(..)) = CopyValue : r594_4 -# 594| r594_6(glval<..(*)(..)>) = VariableAddress[pfn] : -# 594| m594_7(..(*)(..)) = Store : &:r594_6, r594_5 -# 595| v595_1(void) = NoOp : -# 590| v590_4(void) = ReturnVoid : -# 590| v590_5(void) = UnmodeledUse : mu* -# 590| v590_6(void) = AliasedUse : ~m590_2 -# 590| v590_7(void) = ExitFunction : - -# 615| void DeclareObject() -# 615| Block 0 -# 615| v615_1(void) = EnterFunction : -# 615| m615_2(unknown) = AliasedDefinition : -# 615| mu615_3(unknown) = UnmodeledDefinition : -# 616| r616_1(glval) = VariableAddress[s1] : -# 616| m616_2(String) = Uninitialized[s1] : &:r616_1 -# 616| r616_3(glval) = FunctionAddress[String] : -# 616| v616_4(void) = Call : func:r616_3, this:r616_1 -# 616| m616_5(unknown) = ^CallSideEffect : ~m615_2 -# 616| m616_6(unknown) = Chi : total:m615_2, partial:m616_5 -# 616| m616_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r616_1 -# 616| m616_8(String) = Chi : total:m616_2, partial:m616_7 -# 617| r617_1(glval) = VariableAddress[s2] : -# 617| m617_2(String) = Uninitialized[s2] : &:r617_1 -# 617| r617_3(glval) = FunctionAddress[String] : -# 617| r617_4(glval) = StringConstant["hello"] : -# 617| r617_5(char *) = Convert : r617_4 -# 617| v617_6(void) = Call : func:r617_3, this:r617_1, 0:r617_5 -# 617| m617_7(unknown) = ^CallSideEffect : ~m616_6 -# 617| m617_8(unknown) = Chi : total:m616_6, partial:m617_7 -# 617| m617_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r617_1 -# 617| m617_10(String) = Chi : total:m617_2, partial:m617_9 -# 617| v617_11(void) = ^BufferReadSideEffect[0] : &:r617_5, ~m615_2 -# 617| m617_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r617_5 -# 617| m617_13(unknown) = Chi : total:m617_8, partial:m617_12 -# 618| r618_1(glval) = VariableAddress[s3] : -# 618| r618_2(glval) = FunctionAddress[ReturnObject] : -# 618| r618_3(String) = Call : func:r618_2 -# 618| m618_4(unknown) = ^CallSideEffect : ~m617_13 -# 618| m618_5(unknown) = Chi : total:m617_13, partial:m618_4 -# 618| m618_6(String) = Store : &:r618_1, r618_3 -# 619| r619_1(glval) = VariableAddress[s4] : -# 619| m619_2(String) = Uninitialized[s4] : &:r619_1 -# 619| r619_3(glval) = FunctionAddress[String] : -# 619| r619_4(glval) = StringConstant["test"] : -# 619| r619_5(char *) = Convert : r619_4 -# 619| v619_6(void) = Call : func:r619_3, this:r619_1, 0:r619_5 -# 619| m619_7(unknown) = ^CallSideEffect : ~m618_5 -# 619| m619_8(unknown) = Chi : total:m618_5, partial:m619_7 -# 619| m619_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r619_1 -# 619| m619_10(String) = Chi : total:m619_2, partial:m619_9 -# 619| v619_11(void) = ^BufferReadSideEffect[0] : &:r619_5, ~m615_2 -# 619| m619_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r619_5 -# 619| m619_13(unknown) = Chi : total:m619_8, partial:m619_12 -# 620| v620_1(void) = NoOp : -# 615| v615_4(void) = ReturnVoid : -# 615| v615_5(void) = UnmodeledUse : mu* -# 615| v615_6(void) = AliasedUse : ~m619_13 -# 615| v615_7(void) = ExitFunction : - -# 622| void CallMethods(String&, String*, String) -# 622| Block 0 -# 622| v622_1(void) = EnterFunction : -# 622| m622_2(unknown) = AliasedDefinition : -# 622| mu622_3(unknown) = UnmodeledDefinition : -# 622| r622_4(glval) = VariableAddress[r] : -# 622| m622_5(String &) = InitializeParameter[r] : &:r622_4 -# 622| r622_6(String &) = Load : &:r622_4, m622_5 -# 622| m622_7(unknown) = InitializeIndirection[r] : &:r622_6 -# 622| m622_8(unknown) = Chi : total:m622_2, partial:m622_7 -# 622| r622_9(glval) = VariableAddress[p] : -# 622| m622_10(String *) = InitializeParameter[p] : &:r622_9 -# 622| r622_11(String *) = Load : &:r622_9, m622_10 -# 622| m622_12(unknown) = InitializeIndirection[p] : &:r622_11 -# 622| m622_13(unknown) = Chi : total:m622_8, partial:m622_12 -# 622| r622_14(glval) = VariableAddress[s] : -# 622| m622_15(String) = InitializeParameter[s] : &:r622_14 -# 623| r623_1(glval) = VariableAddress[r] : -# 623| r623_2(String &) = Load : &:r623_1, m622_5 -# 623| r623_3(glval) = CopyValue : r623_2 -# 623| r623_4(glval) = Convert : r623_3 -# 623| r623_5(glval) = FunctionAddress[c_str] : -# 623| r623_6(char *) = Call : func:r623_5, this:r623_4 -# 623| m623_7(unknown) = ^CallSideEffect : ~m622_13 -# 623| m623_8(unknown) = Chi : total:m622_13, partial:m623_7 -# 623| v623_9(void) = ^BufferReadSideEffect[-1] : &:r623_4, ~m623_8 -# 623| m623_10(String) = ^IndirectMayWriteSideEffect[-1] : &:r623_4 -# 623| m623_11(unknown) = Chi : total:m623_8, partial:m623_10 -# 624| r624_1(glval) = VariableAddress[p] : -# 624| r624_2(String *) = Load : &:r624_1, m622_10 -# 624| r624_3(String *) = Convert : r624_2 -# 624| r624_4(glval) = FunctionAddress[c_str] : -# 624| r624_5(char *) = Call : func:r624_4, this:r624_3 -# 624| m624_6(unknown) = ^CallSideEffect : ~m623_11 -# 624| m624_7(unknown) = Chi : total:m623_11, partial:m624_6 -# 624| v624_8(void) = ^BufferReadSideEffect[-1] : &:r624_3, ~m624_7 -# 624| m624_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r624_3 -# 624| m624_10(unknown) = Chi : total:m624_7, partial:m624_9 -# 625| r625_1(glval) = VariableAddress[s] : -# 625| r625_2(glval) = Convert : r625_1 -# 625| r625_3(glval) = FunctionAddress[c_str] : -# 625| r625_4(char *) = Call : func:r625_3, this:r625_2 -# 625| m625_5(unknown) = ^CallSideEffect : ~m624_10 -# 625| m625_6(unknown) = Chi : total:m624_10, partial:m625_5 -# 625| v625_7(void) = ^BufferReadSideEffect[-1] : &:r625_2, ~m622_15 -# 625| m625_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r625_2 -# 625| m625_9(String) = Chi : total:m622_15, partial:m625_8 -# 626| v626_1(void) = NoOp : -# 622| v622_16(void) = ReturnIndirection : &:r622_6, ~m625_6 -# 622| v622_17(void) = ReturnIndirection : &:r622_11, ~m625_6 -# 622| v622_18(void) = ReturnVoid : -# 622| v622_19(void) = UnmodeledUse : mu* -# 622| v622_20(void) = AliasedUse : ~m625_6 -# 622| v622_21(void) = ExitFunction : - -# 630| int C::StaticMemberFunction(int) -# 630| Block 0 -# 630| v630_1(void) = EnterFunction : -# 630| m630_2(unknown) = AliasedDefinition : -# 630| mu630_3(unknown) = UnmodeledDefinition : -# 630| r630_4(glval) = VariableAddress[x] : -# 630| m630_5(int) = InitializeParameter[x] : &:r630_4 -# 631| r631_1(glval) = VariableAddress[#return] : -# 631| r631_2(glval) = VariableAddress[x] : -# 631| r631_3(int) = Load : &:r631_2, m630_5 -# 631| m631_4(int) = Store : &:r631_1, r631_3 -# 630| r630_6(glval) = VariableAddress[#return] : -# 630| v630_7(void) = ReturnValue : &:r630_6, m631_4 -# 630| v630_8(void) = UnmodeledUse : mu* -# 630| v630_9(void) = AliasedUse : ~m630_2 -# 630| v630_10(void) = ExitFunction : - -# 634| int C::InstanceMemberFunction(int) -# 634| Block 0 -# 634| v634_1(void) = EnterFunction : -# 634| m634_2(unknown) = AliasedDefinition : -# 634| mu634_3(unknown) = UnmodeledDefinition : -# 634| r634_4(glval) = InitializeThis : -# 634| r634_5(glval) = VariableAddress[x] : -# 634| m634_6(int) = InitializeParameter[x] : &:r634_5 -# 635| r635_1(glval) = VariableAddress[#return] : -# 635| r635_2(glval) = VariableAddress[x] : -# 635| r635_3(int) = Load : &:r635_2, m634_6 -# 635| m635_4(int) = Store : &:r635_1, r635_3 -# 634| r634_7(glval) = VariableAddress[#return] : -# 634| v634_8(void) = ReturnValue : &:r634_7, m635_4 -# 634| v634_9(void) = UnmodeledUse : mu* -# 634| v634_10(void) = AliasedUse : ~m634_2 -# 634| v634_11(void) = ExitFunction : - -# 638| int C::VirtualMemberFunction(int) -# 638| Block 0 -# 638| v638_1(void) = EnterFunction : -# 638| m638_2(unknown) = AliasedDefinition : -# 638| mu638_3(unknown) = UnmodeledDefinition : -# 638| r638_4(glval) = InitializeThis : -# 638| r638_5(glval) = VariableAddress[x] : -# 638| m638_6(int) = InitializeParameter[x] : &:r638_5 -# 639| r639_1(glval) = VariableAddress[#return] : -# 639| r639_2(glval) = VariableAddress[x] : -# 639| r639_3(int) = Load : &:r639_2, m638_6 -# 639| m639_4(int) = Store : &:r639_1, r639_3 -# 638| r638_7(glval) = VariableAddress[#return] : -# 638| v638_8(void) = ReturnValue : &:r638_7, m639_4 -# 638| v638_9(void) = UnmodeledUse : mu* -# 638| v638_10(void) = AliasedUse : ~m638_2 -# 638| v638_11(void) = ExitFunction : - -# 642| void C::FieldAccess() -# 642| Block 0 -# 642| v642_1(void) = EnterFunction : -# 642| m642_2(unknown) = AliasedDefinition : -# 642| mu642_3(unknown) = UnmodeledDefinition : -# 642| r642_4(glval) = InitializeThis : -# 643| r643_1(int) = Constant[0] : -# 643| r643_2(C *) = CopyValue : r642_4 -# 643| r643_3(glval) = FieldAddress[m_a] : r643_2 -# 643| m643_4(int) = Store : &:r643_3, r643_1 -# 643| m643_5(unknown) = Chi : total:m642_2, partial:m643_4 -# 644| r644_1(int) = Constant[1] : -# 644| r644_2(C *) = CopyValue : r642_4 -# 644| r644_3(glval) = CopyValue : r644_2 -# 644| r644_4(glval) = FieldAddress[m_a] : r644_3 -# 644| m644_5(int) = Store : &:r644_4, r644_1 -# 644| m644_6(unknown) = Chi : total:m643_5, partial:m644_5 -# 645| r645_1(int) = Constant[2] : -#-----| r0_1(C *) = CopyValue : r642_4 -# 645| r645_2(glval) = FieldAddress[m_a] : r0_1 -# 645| m645_3(int) = Store : &:r645_2, r645_1 -# 645| m645_4(unknown) = Chi : total:m644_6, partial:m645_3 -# 646| r646_1(glval) = VariableAddress[x] : -# 646| m646_2(int) = Uninitialized[x] : &:r646_1 -# 647| r647_1(C *) = CopyValue : r642_4 -# 647| r647_2(glval) = FieldAddress[m_a] : r647_1 -# 647| r647_3(int) = Load : &:r647_2, ~m645_4 -# 647| r647_4(glval) = VariableAddress[x] : -# 647| m647_5(int) = Store : &:r647_4, r647_3 -# 648| r648_1(C *) = CopyValue : r642_4 -# 648| r648_2(glval) = CopyValue : r648_1 -# 648| r648_3(glval) = FieldAddress[m_a] : r648_2 -# 648| r648_4(int) = Load : &:r648_3, ~m645_4 -# 648| r648_5(glval) = VariableAddress[x] : -# 648| m648_6(int) = Store : &:r648_5, r648_4 -#-----| r0_2(C *) = CopyValue : r642_4 -# 649| r649_1(glval) = FieldAddress[m_a] : r0_2 -# 649| r649_2(int) = Load : &:r649_1, ~m645_4 -# 649| r649_3(glval) = VariableAddress[x] : -# 649| m649_4(int) = Store : &:r649_3, r649_2 -# 650| v650_1(void) = NoOp : -# 642| v642_5(void) = ReturnVoid : -# 642| v642_6(void) = UnmodeledUse : mu* -# 642| v642_7(void) = AliasedUse : ~m645_4 -# 642| v642_8(void) = ExitFunction : - -# 652| void C::MethodCalls() -# 652| Block 0 -# 652| v652_1(void) = EnterFunction : -# 652| m652_2(unknown) = AliasedDefinition : -# 652| mu652_3(unknown) = UnmodeledDefinition : -# 652| r652_4(glval) = InitializeThis : -# 653| r653_1(C *) = CopyValue : r652_4 -# 653| r653_2(glval) = FunctionAddress[InstanceMemberFunction] : -# 653| r653_3(int) = Constant[0] : -# 653| r653_4(int) = Call : func:r653_2, this:r653_1, 0:r653_3 -# 653| m653_5(unknown) = ^CallSideEffect : ~m652_2 -# 653| m653_6(unknown) = Chi : total:m652_2, partial:m653_5 -# 653| v653_7(void) = ^BufferReadSideEffect[-1] : &:r653_1, ~m653_6 -# 653| m653_8(C) = ^IndirectMayWriteSideEffect[-1] : &:r653_1 -# 653| m653_9(unknown) = Chi : total:m653_6, partial:m653_8 -# 654| r654_1(C *) = CopyValue : r652_4 -# 654| r654_2(glval) = CopyValue : r654_1 -# 654| r654_3(glval) = FunctionAddress[InstanceMemberFunction] : -# 654| r654_4(int) = Constant[1] : -# 654| r654_5(int) = Call : func:r654_3, this:r654_2, 0:r654_4 -# 654| m654_6(unknown) = ^CallSideEffect : ~m653_9 -# 654| m654_7(unknown) = Chi : total:m653_9, partial:m654_6 -# 654| v654_8(void) = ^BufferReadSideEffect[-1] : &:r654_2, ~m654_7 -# 654| m654_9(C) = ^IndirectMayWriteSideEffect[-1] : &:r654_2 -# 654| m654_10(unknown) = Chi : total:m654_7, partial:m654_9 -#-----| r0_1(C *) = CopyValue : r652_4 -# 655| r655_1(glval) = FunctionAddress[InstanceMemberFunction] : -# 655| r655_2(int) = Constant[2] : -# 655| r655_3(int) = Call : func:r655_1, this:r0_1, 0:r655_2 -# 655| m655_4(unknown) = ^CallSideEffect : ~m654_10 -# 655| m655_5(unknown) = Chi : total:m654_10, partial:m655_4 -#-----| v0_2(void) = ^BufferReadSideEffect[-1] : &:r0_1, ~m655_5 -#-----| m0_3(C) = ^IndirectMayWriteSideEffect[-1] : &:r0_1 -#-----| m0_4(unknown) = Chi : total:m655_5, partial:m0_3 -# 656| v656_1(void) = NoOp : -# 652| v652_5(void) = ReturnVoid : -# 652| v652_6(void) = UnmodeledUse : mu* -# 652| v652_7(void) = AliasedUse : ~m0_4 -# 652| v652_8(void) = ExitFunction : - -# 658| void C::C() -# 658| Block 0 -# 658| v658_1(void) = EnterFunction : -# 658| m658_2(unknown) = AliasedDefinition : -# 658| mu658_3(unknown) = UnmodeledDefinition : -# 658| r658_4(glval) = InitializeThis : -# 659| r659_1(glval) = FieldAddress[m_a] : r658_4 -# 659| r659_2(int) = Constant[1] : -# 659| m659_3(int) = Store : &:r659_1, r659_2 -# 659| m659_4(unknown) = Chi : total:m658_2, partial:m659_3 -# 663| r663_1(glval) = FieldAddress[m_b] : r658_4 -# 663| r663_2(glval) = FunctionAddress[String] : -# 663| v663_3(void) = Call : func:r663_2, this:r663_1 -# 663| m663_4(unknown) = ^CallSideEffect : ~m659_4 -# 663| m663_5(unknown) = Chi : total:m659_4, partial:m663_4 -# 663| m663_6(String) = ^IndirectMayWriteSideEffect[-1] : &:r663_1 -# 663| m663_7(unknown) = Chi : total:m663_5, partial:m663_6 -# 660| r660_1(glval) = FieldAddress[m_c] : r658_4 -# 660| r660_2(char) = Constant[3] : -# 660| m660_3(char) = Store : &:r660_1, r660_2 -# 660| m660_4(unknown) = Chi : total:m663_7, partial:m660_3 -# 661| r661_1(glval) = FieldAddress[m_e] : r658_4 -# 661| r661_2(void *) = Constant[0] : -# 661| m661_3(void *) = Store : &:r661_1, r661_2 -# 661| m661_4(unknown) = Chi : total:m660_4, partial:m661_3 -# 662| r662_1(glval) = FieldAddress[m_f] : r658_4 -# 662| r662_2(glval) = FunctionAddress[String] : -# 662| r662_3(glval) = StringConstant["test"] : -# 662| r662_4(char *) = Convert : r662_3 -# 662| v662_5(void) = Call : func:r662_2, this:r662_1, 0:r662_4 -# 662| m662_6(unknown) = ^CallSideEffect : ~m661_4 -# 662| m662_7(unknown) = Chi : total:m661_4, partial:m662_6 -# 662| m662_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r662_1 -# 662| m662_9(unknown) = Chi : total:m662_7, partial:m662_8 -# 662| v662_10(void) = ^BufferReadSideEffect[0] : &:r662_4, ~m658_2 -# 662| m662_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r662_4 -# 662| m662_12(unknown) = Chi : total:m662_9, partial:m662_11 -# 664| v664_1(void) = NoOp : -# 658| v658_5(void) = ReturnVoid : -# 658| v658_6(void) = UnmodeledUse : mu* -# 658| v658_7(void) = AliasedUse : ~m662_12 -# 658| v658_8(void) = ExitFunction : - -# 675| int DerefReference(int&) -# 675| Block 0 -# 675| v675_1(void) = EnterFunction : -# 675| m675_2(unknown) = AliasedDefinition : -# 675| mu675_3(unknown) = UnmodeledDefinition : -# 675| r675_4(glval) = VariableAddress[r] : -# 675| m675_5(int &) = InitializeParameter[r] : &:r675_4 -# 675| r675_6(int &) = Load : &:r675_4, m675_5 -# 675| m675_7(unknown) = InitializeIndirection[r] : &:r675_6 -# 675| m675_8(unknown) = Chi : total:m675_2, partial:m675_7 -# 676| r676_1(glval) = VariableAddress[#return] : -# 676| r676_2(glval) = VariableAddress[r] : -# 676| r676_3(int &) = Load : &:r676_2, m675_5 -# 676| r676_4(int) = Load : &:r676_3, ~m675_8 -# 676| m676_5(int) = Store : &:r676_1, r676_4 -# 675| v675_9(void) = ReturnIndirection : &:r675_6, ~m675_8 -# 675| r675_10(glval) = VariableAddress[#return] : -# 675| v675_11(void) = ReturnValue : &:r675_10, m676_5 -# 675| v675_12(void) = UnmodeledUse : mu* -# 675| v675_13(void) = AliasedUse : ~m675_8 -# 675| v675_14(void) = ExitFunction : - -# 679| int& TakeReference() -# 679| Block 0 -# 679| v679_1(void) = EnterFunction : -# 679| m679_2(unknown) = AliasedDefinition : -# 679| mu679_3(unknown) = UnmodeledDefinition : -# 680| r680_1(glval) = VariableAddress[#return] : -# 680| r680_2(glval) = VariableAddress[g] : -# 680| r680_3(int &) = CopyValue : r680_2 -# 680| m680_4(int &) = Store : &:r680_1, r680_3 -# 679| r679_4(glval) = VariableAddress[#return] : -# 679| v679_5(void) = ReturnValue : &:r679_4, m680_4 -# 679| v679_6(void) = UnmodeledUse : mu* -# 679| v679_7(void) = AliasedUse : ~m679_2 -# 679| v679_8(void) = ExitFunction : - -# 685| void InitReference(int) -# 685| Block 0 -# 685| v685_1(void) = EnterFunction : -# 685| m685_2(unknown) = AliasedDefinition : -# 685| mu685_3(unknown) = UnmodeledDefinition : -# 685| r685_4(glval) = VariableAddress[x] : -# 685| m685_5(int) = InitializeParameter[x] : &:r685_4 -# 686| r686_1(glval) = VariableAddress[r] : -# 686| r686_2(glval) = VariableAddress[x] : -# 686| r686_3(int &) = CopyValue : r686_2 -# 686| m686_4(int &) = Store : &:r686_1, r686_3 -# 687| r687_1(glval) = VariableAddress[r2] : -# 687| r687_2(glval) = VariableAddress[r] : -# 687| r687_3(int &) = Load : &:r687_2, m686_4 -# 687| r687_4(glval) = CopyValue : r687_3 -# 687| r687_5(int &) = CopyValue : r687_4 -# 687| m687_6(int &) = Store : &:r687_1, r687_5 -# 688| r688_1(glval) = VariableAddress[r3] : -# 688| r688_2(glval) = FunctionAddress[ReturnReference] : -# 688| r688_3(String &) = Call : func:r688_2 -# 688| m688_4(unknown) = ^CallSideEffect : ~m685_2 -# 688| m688_5(unknown) = Chi : total:m685_2, partial:m688_4 -# 688| r688_6(glval) = CopyValue : r688_3 -# 688| r688_7(glval) = Convert : r688_6 -# 688| r688_8(String &) = CopyValue : r688_7 -# 688| m688_9(String &) = Store : &:r688_1, r688_8 -# 689| v689_1(void) = NoOp : -# 685| v685_6(void) = ReturnVoid : -# 685| v685_7(void) = UnmodeledUse : mu* -# 685| v685_8(void) = AliasedUse : ~m688_5 -# 685| v685_9(void) = ExitFunction : - -# 691| void ArrayReferences() -# 691| Block 0 -# 691| v691_1(void) = EnterFunction : -# 691| m691_2(unknown) = AliasedDefinition : -# 691| mu691_3(unknown) = UnmodeledDefinition : -# 692| r692_1(glval) = VariableAddress[a] : -# 692| m692_2(int[10]) = Uninitialized[a] : &:r692_1 -# 693| r693_1(glval) = VariableAddress[ra] : -# 693| r693_2(glval) = VariableAddress[a] : -# 693| r693_3(int(&)[10]) = CopyValue : r693_2 -# 693| m693_4(int(&)[10]) = Store : &:r693_1, r693_3 -# 694| r694_1(glval) = VariableAddress[x] : -# 694| r694_2(glval) = VariableAddress[ra] : -# 694| r694_3(int(&)[10]) = Load : &:r694_2, m693_4 -# 694| r694_4(glval) = CopyValue : r694_3 -# 694| r694_5(int *) = Convert : r694_4 -# 694| r694_6(int) = Constant[5] : -# 694| r694_7(glval) = PointerAdd[4] : r694_5, r694_6 -# 694| r694_8(int) = Load : &:r694_7, ~m692_2 -# 694| m694_9(int) = Store : &:r694_1, r694_8 -# 695| v695_1(void) = NoOp : -# 691| v691_4(void) = ReturnVoid : -# 691| v691_5(void) = UnmodeledUse : mu* -# 691| v691_6(void) = AliasedUse : ~m691_2 -# 691| v691_7(void) = ExitFunction : - -# 697| void FunctionReferences() -# 697| Block 0 -# 697| v697_1(void) = EnterFunction : -# 697| m697_2(unknown) = AliasedDefinition : -# 697| mu697_3(unknown) = UnmodeledDefinition : -# 698| r698_1(glval<..(&)(..)>) = VariableAddress[rfn] : -# 698| r698_2(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 698| r698_3(..(&)(..)) = CopyValue : r698_2 -# 698| m698_4(..(&)(..)) = Store : &:r698_1, r698_3 -# 699| r699_1(glval<..(*)(..)>) = VariableAddress[pfn] : -# 699| r699_2(glval<..(&)(..)>) = VariableAddress[rfn] : -# 699| r699_3(..(&)(..)) = Load : &:r699_2, m698_4 -# 699| r699_4(..(*)(..)) = CopyValue : r699_3 -# 699| m699_5(..(*)(..)) = Store : &:r699_1, r699_4 -# 700| r700_1(glval<..(&)(..)>) = VariableAddress[rfn] : -# 700| r700_2(..(&)(..)) = Load : &:r700_1, m698_4 -# 700| r700_3(..(*)(..)) = CopyValue : r700_2 -# 700| r700_4(int) = Constant[5] : -# 700| r700_5(int) = Call : func:r700_3, 0:r700_4 -# 700| m700_6(unknown) = ^CallSideEffect : ~m697_2 -# 700| m700_7(unknown) = Chi : total:m697_2, partial:m700_6 -# 701| v701_1(void) = NoOp : -# 697| v697_4(void) = ReturnVoid : -# 697| v697_5(void) = UnmodeledUse : mu* -# 697| v697_6(void) = AliasedUse : ~m700_7 -# 697| v697_7(void) = ExitFunction : - -# 704| int min(int, int) -# 704| Block 0 -# 704| v704_1(void) = EnterFunction : -# 704| m704_2(unknown) = AliasedDefinition : -# 704| mu704_3(unknown) = UnmodeledDefinition : -# 704| r704_4(glval) = VariableAddress[x] : -# 704| m704_5(int) = InitializeParameter[x] : &:r704_4 -# 704| r704_6(glval) = VariableAddress[y] : -# 704| m704_7(int) = InitializeParameter[y] : &:r704_6 -# 705| r705_1(glval) = VariableAddress[#return] : -# 705| r705_2(glval) = VariableAddress[x] : -# 705| r705_3(int) = Load : &:r705_2, m704_5 -# 705| r705_4(glval) = VariableAddress[y] : -# 705| r705_5(int) = Load : &:r705_4, m704_7 -# 705| r705_6(bool) = CompareLT : r705_3, r705_5 -# 705| v705_7(void) = ConditionalBranch : r705_6 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 705| Block 1 -# 705| r705_8(glval) = VariableAddress[x] : -# 705| r705_9(int) = Load : &:r705_8, m704_5 -# 705| r705_10(glval) = VariableAddress[#temp705:10] : -# 705| m705_11(int) = Store : &:r705_10, r705_9 -#-----| Goto -> Block 3 - -# 705| Block 2 -# 705| r705_12(glval) = VariableAddress[y] : -# 705| r705_13(int) = Load : &:r705_12, m704_7 -# 705| r705_14(glval) = VariableAddress[#temp705:10] : -# 705| m705_15(int) = Store : &:r705_14, r705_13 -#-----| Goto -> Block 3 - -# 705| Block 3 -# 705| m705_16(int) = Phi : from 1:m705_11, from 2:m705_15 -# 705| r705_17(glval) = VariableAddress[#temp705:10] : -# 705| r705_18(int) = Load : &:r705_17, m705_16 -# 705| m705_19(int) = Store : &:r705_1, r705_18 -# 704| r704_8(glval) = VariableAddress[#return] : -# 704| v704_9(void) = ReturnValue : &:r704_8, m705_19 -# 704| v704_10(void) = UnmodeledUse : mu* -# 704| v704_11(void) = AliasedUse : ~m704_2 -# 704| v704_12(void) = ExitFunction : - -# 708| int CallMin(int, int) -# 708| Block 0 -# 708| v708_1(void) = EnterFunction : -# 708| m708_2(unknown) = AliasedDefinition : -# 708| mu708_3(unknown) = UnmodeledDefinition : -# 708| r708_4(glval) = VariableAddress[x] : -# 708| m708_5(int) = InitializeParameter[x] : &:r708_4 -# 708| r708_6(glval) = VariableAddress[y] : -# 708| m708_7(int) = InitializeParameter[y] : &:r708_6 -# 709| r709_1(glval) = VariableAddress[#return] : -# 709| r709_2(glval) = FunctionAddress[min] : -# 709| r709_3(glval) = VariableAddress[x] : -# 709| r709_4(int) = Load : &:r709_3, m708_5 -# 709| r709_5(glval) = VariableAddress[y] : -# 709| r709_6(int) = Load : &:r709_5, m708_7 -# 709| r709_7(int) = Call : func:r709_2, 0:r709_4, 1:r709_6 -# 709| m709_8(unknown) = ^CallSideEffect : ~m708_2 -# 709| m709_9(unknown) = Chi : total:m708_2, partial:m709_8 -# 709| m709_10(int) = Store : &:r709_1, r709_7 -# 708| r708_8(glval) = VariableAddress[#return] : -# 708| v708_9(void) = ReturnValue : &:r708_8, m709_10 -# 708| v708_10(void) = UnmodeledUse : mu* -# 708| v708_11(void) = AliasedUse : ~m709_9 -# 708| v708_12(void) = ExitFunction : - -# 715| long Outer::Func(void*, char) -# 715| Block 0 -# 715| v715_1(void) = EnterFunction : -# 715| m715_2(unknown) = AliasedDefinition : -# 715| mu715_3(unknown) = UnmodeledDefinition : -# 715| r715_4(glval) = VariableAddress[x] : -# 715| m715_5(void *) = InitializeParameter[x] : &:r715_4 -# 715| r715_6(void *) = Load : &:r715_4, m715_5 -# 715| m715_7(unknown) = InitializeIndirection[x] : &:r715_6 -# 715| m715_8(unknown) = Chi : total:m715_2, partial:m715_7 -# 715| r715_9(glval) = VariableAddress[y] : -# 715| m715_10(char) = InitializeParameter[y] : &:r715_9 -# 716| r716_1(glval) = VariableAddress[#return] : -# 716| r716_2(long) = Constant[0] : -# 716| m716_3(long) = Store : &:r716_1, r716_2 -# 715| v715_11(void) = ReturnIndirection : &:r715_6, ~m715_8 -# 715| r715_12(glval) = VariableAddress[#return] : -# 715| v715_13(void) = ReturnValue : &:r715_12, m716_3 -# 715| v715_14(void) = UnmodeledUse : mu* -# 715| v715_15(void) = AliasedUse : ~m715_8 -# 715| v715_16(void) = ExitFunction : - -# 720| double CallNestedTemplateFunc() -# 720| Block 0 -# 720| v720_1(void) = EnterFunction : -# 720| m720_2(unknown) = AliasedDefinition : -# 720| mu720_3(unknown) = UnmodeledDefinition : -# 721| r721_1(glval) = VariableAddress[#return] : -# 721| r721_2(glval) = FunctionAddress[Func] : -# 721| r721_3(void *) = Constant[0] : -# 721| r721_4(char) = Constant[111] : -# 721| r721_5(long) = Call : func:r721_2, 0:r721_3, 1:r721_4 -# 721| m721_6(unknown) = ^CallSideEffect : ~m720_2 -# 721| m721_7(unknown) = Chi : total:m720_2, partial:m721_6 -# 721| v721_8(void) = ^BufferReadSideEffect[0] : &:r721_3, ~m721_7 -# 721| m721_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r721_3 -# 721| m721_10(unknown) = Chi : total:m721_7, partial:m721_9 -# 721| r721_11(double) = Convert : r721_5 -# 721| m721_12(double) = Store : &:r721_1, r721_11 -# 720| r720_4(glval) = VariableAddress[#return] : -# 720| v720_5(void) = ReturnValue : &:r720_4, m721_12 -# 720| v720_6(void) = UnmodeledUse : mu* -# 720| v720_7(void) = AliasedUse : ~m721_10 -# 720| v720_8(void) = ExitFunction : - -# 724| void TryCatch(bool) -# 724| Block 0 -# 724| v724_1(void) = EnterFunction : -# 724| m724_2(unknown) = AliasedDefinition : -# 724| mu724_3(unknown) = UnmodeledDefinition : -# 724| r724_4(glval) = VariableAddress[b] : -# 724| m724_5(bool) = InitializeParameter[b] : &:r724_4 -# 726| r726_1(glval) = VariableAddress[x] : -# 726| r726_2(int) = Constant[5] : -# 726| m726_3(int) = Store : &:r726_1, r726_2 -# 727| r727_1(glval) = VariableAddress[b] : -# 727| r727_2(bool) = Load : &:r727_1, m724_5 -# 727| v727_3(void) = ConditionalBranch : r727_2 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 724| Block 1 -# 724| m724_6(unknown) = Phi : from 2:~m724_10, from 11:~m743_1 -# 724| v724_7(void) = UnmodeledUse : mu* -# 724| v724_8(void) = AliasedUse : ~m724_6 -# 724| v724_9(void) = ExitFunction : - -# 724| Block 2 -# 724| m724_10(unknown) = Phi : from 7:~m736_13, from 10:~m724_2 -# 724| v724_11(void) = Unwind : -#-----| Goto -> Block 1 - -# 728| Block 3 -# 728| r728_1(glval) = VariableAddress[#throw728:7] : -# 728| r728_2(glval) = StringConstant["string literal"] : -# 728| r728_3(char *) = Convert : r728_2 -# 728| m728_4(char *) = Store : &:r728_1, r728_3 -# 728| v728_5(void) = ThrowValue : &:r728_1, m728_4 -#-----| Exception -> Block 6 - -# 730| Block 4 -# 730| r730_1(glval) = VariableAddress[x] : -# 730| r730_2(int) = Load : &:r730_1, m726_3 -# 730| r730_3(int) = Constant[2] : -# 730| r730_4(bool) = CompareLT : r730_2, r730_3 -# 730| v730_5(void) = ConditionalBranch : r730_4 -#-----| False -> Block 5 -#-----| True -> Block 12 - -# 733| Block 5 -# 733| r733_1(int) = Constant[7] : -# 733| r733_2(glval) = VariableAddress[x] : -# 733| m733_3(int) = Store : &:r733_2, r733_1 -#-----| Goto -> Block 11 - -# 735| Block 6 -# 735| v735_1(void) = CatchByType[const char *] : -#-----| Exception -> Block 8 -#-----| Goto -> Block 7 - -# 735| Block 7 -# 735| r735_2(glval) = VariableAddress[s] : -# 735| m735_3(char *) = InitializeParameter[s] : &:r735_2 -# 735| r735_4(char *) = Load : &:r735_2, m735_3 -# 735| m735_5(unknown) = InitializeIndirection[s] : &:r735_4 -# 735| m735_6(unknown) = Chi : total:m724_2, partial:m735_5 -# 736| r736_1(glval) = VariableAddress[#throw736:5] : -# 736| m736_2(String) = Uninitialized[#throw736:5] : &:r736_1 -# 736| r736_3(glval) = FunctionAddress[String] : -# 736| r736_4(glval) = VariableAddress[s] : -# 736| r736_5(char *) = Load : &:r736_4, m735_3 -# 736| v736_6(void) = Call : func:r736_3, this:r736_1, 0:r736_5 -# 736| m736_7(unknown) = ^CallSideEffect : ~m735_6 -# 736| m736_8(unknown) = Chi : total:m735_6, partial:m736_7 -# 736| m736_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r736_1 -# 736| m736_10(String) = Chi : total:m736_2, partial:m736_9 -# 736| v736_11(void) = ^BufferReadSideEffect[0] : &:r736_5, ~m736_8 -# 736| m736_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r736_5 -# 736| m736_13(unknown) = Chi : total:m736_8, partial:m736_12 -# 736| v736_14(void) = ThrowValue : &:r736_1, ~m736_10 -#-----| Exception -> Block 2 - -# 738| Block 8 -# 738| v738_1(void) = CatchByType[const String &] : -#-----| Exception -> Block 10 -#-----| Goto -> Block 9 - -# 738| Block 9 -# 738| r738_2(glval) = VariableAddress[e] : -# 738| m738_3(String &) = InitializeParameter[e] : &:r738_2 -# 738| r738_4(String &) = Load : &:r738_2, m738_3 -# 738| m738_5(unknown) = InitializeIndirection[e] : &:r738_4 -# 738| m738_6(unknown) = Chi : total:m724_2, partial:m738_5 -# 738| v738_7(void) = NoOp : -#-----| Goto -> Block 11 - -# 740| Block 10 -# 740| v740_1(void) = CatchAny : -# 741| v741_1(void) = ReThrow : -#-----| Exception -> Block 2 - -# 743| Block 11 -# 743| m743_1(unknown) = Phi : from 5:~m724_2, from 9:~m738_6 -# 743| v743_2(void) = NoOp : -# 724| v724_12(void) = ReturnVoid : -#-----| Goto -> Block 1 - -# 724| Block 12 -# 724| v724_13(void) = Unreached : - -# 745| Base& Base::operator=(Base const&) -# 745| Block 0 -# 745| v745_1(void) = EnterFunction : -# 745| m745_2(unknown) = AliasedDefinition : -# 745| mu745_3(unknown) = UnmodeledDefinition : -# 745| r745_4(glval) = InitializeThis : -#-----| r0_1(glval) = VariableAddress[p#0] : -#-----| m0_2(Base &) = InitializeParameter[p#0] : &:r0_1 -#-----| r0_3(Base &) = Load : &:r0_1, m0_2 -#-----| m0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 -#-----| m0_5(unknown) = Chi : total:m745_2, partial:m0_4 -#-----| r0_6(Base *) = CopyValue : r745_4 -#-----| r0_7(glval) = FieldAddress[base_s] : r0_6 -#-----| r0_8(String *) = CopyValue : r0_7 -# 745| r745_5(glval) = FunctionAddress[operator=] : -#-----| r0_9(glval) = VariableAddress[p#0] : -#-----| r0_10(Base &) = Load : &:r0_9, m0_2 -#-----| r0_11(glval) = CopyValue : r0_10 -#-----| r0_12(glval) = FieldAddress[base_s] : r0_11 -#-----| r0_13(String &) = CopyValue : r0_12 -# 745| r745_6(String &) = Call : func:r745_5, this:r0_8, 0:r0_13 -# 745| m745_7(unknown) = ^CallSideEffect : ~m0_5 -# 745| m745_8(unknown) = Chi : total:m0_5, partial:m745_7 -#-----| v0_14(void) = ^BufferReadSideEffect[-1] : &:r0_8, ~m745_8 -#-----| v0_15(void) = ^BufferReadSideEffect[0] : &:r0_13, ~m745_8 -#-----| m0_16(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 -#-----| m0_17(unknown) = Chi : total:m745_8, partial:m0_16 -#-----| m0_18(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_13 -#-----| m0_19(unknown) = Chi : total:m0_17, partial:m0_18 -#-----| r0_20(glval) = CopyValue : r745_6 -#-----| r0_21(glval) = VariableAddress[#return] : -#-----| r0_22(Base *) = CopyValue : r745_4 -#-----| r0_23(glval) = CopyValue : r0_22 -#-----| r0_24(Base &) = CopyValue : r0_23 -#-----| m0_25(Base &) = Store : &:r0_21, r0_24 -#-----| v0_26(void) = ReturnIndirection : &:r0_3, ~m0_19 -# 745| r745_9(glval) = VariableAddress[#return] : -# 745| v745_10(void) = ReturnValue : &:r745_9, m0_25 -# 745| v745_11(void) = UnmodeledUse : mu* -# 745| v745_12(void) = AliasedUse : ~m0_19 -# 745| v745_13(void) = ExitFunction : - -# 745| void Base::Base(Base const&) -# 745| Block 0 -# 745| v745_1(void) = EnterFunction : -# 745| m745_2(unknown) = AliasedDefinition : -# 745| mu745_3(unknown) = UnmodeledDefinition : -# 745| r745_4(glval) = InitializeThis : -#-----| r0_1(glval) = VariableAddress[p#0] : -#-----| m0_2(Base &) = InitializeParameter[p#0] : &:r0_1 -#-----| r0_3(Base &) = Load : &:r0_1, m0_2 -#-----| m0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 -#-----| m0_5(unknown) = Chi : total:m745_2, partial:m0_4 -# 745| r745_5(glval) = FieldAddress[base_s] : r745_4 -# 745| r745_6(glval) = FunctionAddress[String] : -# 745| v745_7(void) = Call : func:r745_6, this:r745_5 -# 745| m745_8(unknown) = ^CallSideEffect : ~m0_5 -# 745| m745_9(unknown) = Chi : total:m0_5, partial:m745_8 -# 745| m745_10(String) = ^IndirectMayWriteSideEffect[-1] : &:r745_5 -# 745| m745_11(unknown) = Chi : total:m745_9, partial:m745_10 -# 745| v745_12(void) = NoOp : -#-----| v0_6(void) = ReturnIndirection : &:r0_3, ~m745_11 -# 745| v745_13(void) = ReturnVoid : -# 745| v745_14(void) = UnmodeledUse : mu* -# 745| v745_15(void) = AliasedUse : ~m745_11 -# 745| v745_16(void) = ExitFunction : - -# 748| void Base::Base() -# 748| Block 0 -# 748| v748_1(void) = EnterFunction : -# 748| m748_2(unknown) = AliasedDefinition : -# 748| mu748_3(unknown) = UnmodeledDefinition : -# 748| r748_4(glval) = InitializeThis : -# 748| r748_5(glval) = FieldAddress[base_s] : r748_4 -# 748| r748_6(glval) = FunctionAddress[String] : -# 748| v748_7(void) = Call : func:r748_6, this:r748_5 -# 748| m748_8(unknown) = ^CallSideEffect : ~m748_2 -# 748| m748_9(unknown) = Chi : total:m748_2, partial:m748_8 -# 748| m748_10(String) = ^IndirectMayWriteSideEffect[-1] : &:r748_5 -# 748| m748_11(unknown) = Chi : total:m748_9, partial:m748_10 -# 749| v749_1(void) = NoOp : -# 748| v748_12(void) = ReturnVoid : -# 748| v748_13(void) = UnmodeledUse : mu* -# 748| v748_14(void) = AliasedUse : ~m748_11 -# 748| v748_15(void) = ExitFunction : - -# 750| void Base::~Base() -# 750| Block 0 -# 750| v750_1(void) = EnterFunction : -# 750| m750_2(unknown) = AliasedDefinition : -# 750| mu750_3(unknown) = UnmodeledDefinition : -# 750| r750_4(glval) = InitializeThis : -# 751| v751_1(void) = NoOp : -# 751| r751_2(glval) = FieldAddress[base_s] : r750_4 -# 751| r751_3(glval) = FunctionAddress[~String] : -# 751| v751_4(void) = Call : func:r751_3, this:r751_2 -# 751| m751_5(unknown) = ^CallSideEffect : ~m750_2 -# 751| m751_6(unknown) = Chi : total:m750_2, partial:m751_5 -# 750| v750_5(void) = ReturnVoid : -# 750| v750_6(void) = UnmodeledUse : mu* -# 750| v750_7(void) = AliasedUse : ~m751_6 -# 750| v750_8(void) = ExitFunction : - -# 754| Middle& Middle::operator=(Middle const&) -# 754| Block 0 -# 754| v754_1(void) = EnterFunction : -# 754| m754_2(unknown) = AliasedDefinition : -# 754| mu754_3(unknown) = UnmodeledDefinition : -# 754| r754_4(glval) = InitializeThis : -#-----| r0_1(glval) = VariableAddress[p#0] : -#-----| m0_2(Middle &) = InitializeParameter[p#0] : &:r0_1 -#-----| r0_3(Middle &) = Load : &:r0_1, m0_2 -#-----| m0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 -#-----| m0_5(unknown) = Chi : total:m754_2, partial:m0_4 -#-----| r0_6(Middle *) = CopyValue : r754_4 -#-----| r0_7(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_6 -# 754| r754_5(glval) = FunctionAddress[operator=] : -#-----| r0_8(glval) = VariableAddress[p#0] : -#-----| r0_9(Middle &) = Load : &:r0_8, m0_2 -#-----| r0_10(glval) = CopyValue : r0_9 -#-----| r0_11(Middle *) = CopyValue : r0_10 -#-----| r0_12(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_11 -#-----| r0_13(glval) = CopyValue : r0_12 -#-----| r0_14(Base &) = CopyValue : r0_13 -# 754| r754_6(Base &) = Call : func:r754_5, this:r0_7, 0:r0_14 -# 754| m754_7(unknown) = ^CallSideEffect : ~m0_5 -# 754| m754_8(unknown) = Chi : total:m0_5, partial:m754_7 -#-----| v0_15(void) = ^BufferReadSideEffect[-1] : &:r0_7, ~m754_8 -#-----| v0_16(void) = ^BufferReadSideEffect[0] : &:r0_14, ~m754_8 -#-----| m0_17(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_7 -#-----| m0_18(unknown) = Chi : total:m754_8, partial:m0_17 -#-----| m0_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_14 -#-----| m0_20(unknown) = Chi : total:m0_18, partial:m0_19 -#-----| r0_21(glval) = CopyValue : r754_6 -#-----| r0_22(Middle *) = CopyValue : r754_4 -#-----| r0_23(glval) = FieldAddress[middle_s] : r0_22 -#-----| r0_24(String *) = CopyValue : r0_23 -# 754| r754_9(glval) = FunctionAddress[operator=] : -#-----| r0_25(glval) = VariableAddress[p#0] : -#-----| r0_26(Middle &) = Load : &:r0_25, m0_2 -#-----| r0_27(glval) = CopyValue : r0_26 -#-----| r0_28(glval) = FieldAddress[middle_s] : r0_27 -#-----| r0_29(String &) = CopyValue : r0_28 -# 754| r754_10(String &) = Call : func:r754_9, this:r0_24, 0:r0_29 -# 754| m754_11(unknown) = ^CallSideEffect : ~m0_20 -# 754| m754_12(unknown) = Chi : total:m0_20, partial:m754_11 -#-----| v0_30(void) = ^BufferReadSideEffect[-1] : &:r0_24, ~m754_12 -#-----| v0_31(void) = ^BufferReadSideEffect[0] : &:r0_29, ~m754_12 -#-----| m0_32(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_24 -#-----| m0_33(unknown) = Chi : total:m754_12, partial:m0_32 -#-----| m0_34(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_29 -#-----| m0_35(unknown) = Chi : total:m0_33, partial:m0_34 -#-----| r0_36(glval) = CopyValue : r754_10 -#-----| r0_37(glval) = VariableAddress[#return] : -#-----| r0_38(Middle *) = CopyValue : r754_4 -#-----| r0_39(glval) = CopyValue : r0_38 -#-----| r0_40(Middle &) = CopyValue : r0_39 -#-----| m0_41(Middle &) = Store : &:r0_37, r0_40 -#-----| v0_42(void) = ReturnIndirection : &:r0_3, ~m0_35 -# 754| r754_13(glval) = VariableAddress[#return] : -# 754| v754_14(void) = ReturnValue : &:r754_13, m0_41 -# 754| v754_15(void) = UnmodeledUse : mu* -# 754| v754_16(void) = AliasedUse : ~m0_35 -# 754| v754_17(void) = ExitFunction : - -# 757| void Middle::Middle() -# 757| Block 0 -# 757| v757_1(void) = EnterFunction : -# 757| m757_2(unknown) = AliasedDefinition : -# 757| mu757_3(unknown) = UnmodeledDefinition : -# 757| r757_4(glval) = InitializeThis : -# 757| r757_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r757_4 -# 757| r757_6(glval) = FunctionAddress[Base] : -# 757| v757_7(void) = Call : func:r757_6, this:r757_5 -# 757| m757_8(unknown) = ^CallSideEffect : ~m757_2 -# 757| m757_9(unknown) = Chi : total:m757_2, partial:m757_8 -# 757| m757_10(Base) = ^IndirectMayWriteSideEffect[-1] : &:r757_5 -# 757| m757_11(unknown) = Chi : total:m757_9, partial:m757_10 -# 757| r757_12(glval) = FieldAddress[middle_s] : r757_4 -# 757| r757_13(glval) = FunctionAddress[String] : -# 757| v757_14(void) = Call : func:r757_13, this:r757_12 -# 757| m757_15(unknown) = ^CallSideEffect : ~m757_11 -# 757| m757_16(unknown) = Chi : total:m757_11, partial:m757_15 -# 757| m757_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r757_12 -# 757| m757_18(unknown) = Chi : total:m757_16, partial:m757_17 -# 758| v758_1(void) = NoOp : -# 757| v757_19(void) = ReturnVoid : -# 757| v757_20(void) = UnmodeledUse : mu* -# 757| v757_21(void) = AliasedUse : ~m757_18 -# 757| v757_22(void) = ExitFunction : - -# 759| void Middle::~Middle() -# 759| Block 0 -# 759| v759_1(void) = EnterFunction : -# 759| m759_2(unknown) = AliasedDefinition : -# 759| mu759_3(unknown) = UnmodeledDefinition : -# 759| r759_4(glval) = InitializeThis : -# 760| v760_1(void) = NoOp : -# 760| r760_2(glval) = FieldAddress[middle_s] : r759_4 -# 760| r760_3(glval) = FunctionAddress[~String] : -# 760| v760_4(void) = Call : func:r760_3, this:r760_2 -# 760| m760_5(unknown) = ^CallSideEffect : ~m759_2 -# 760| m760_6(unknown) = Chi : total:m759_2, partial:m760_5 -# 760| r760_7(glval) = ConvertToNonVirtualBase[Middle : Base] : r759_4 -# 760| r760_8(glval) = FunctionAddress[~Base] : -# 760| v760_9(void) = Call : func:r760_8, this:r760_7 -# 760| m760_10(unknown) = ^CallSideEffect : ~m760_6 -# 760| m760_11(unknown) = Chi : total:m760_6, partial:m760_10 -# 759| v759_5(void) = ReturnVoid : -# 759| v759_6(void) = UnmodeledUse : mu* -# 759| v759_7(void) = AliasedUse : ~m760_11 -# 759| v759_8(void) = ExitFunction : - -# 763| Derived& Derived::operator=(Derived const&) -# 763| Block 0 -# 763| v763_1(void) = EnterFunction : -# 763| m763_2(unknown) = AliasedDefinition : -# 763| mu763_3(unknown) = UnmodeledDefinition : -# 763| r763_4(glval) = InitializeThis : -#-----| r0_1(glval) = VariableAddress[p#0] : -#-----| m0_2(Derived &) = InitializeParameter[p#0] : &:r0_1 -#-----| r0_3(Derived &) = Load : &:r0_1, m0_2 -#-----| m0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 -#-----| m0_5(unknown) = Chi : total:m763_2, partial:m0_4 -#-----| r0_6(Derived *) = CopyValue : r763_4 -#-----| r0_7(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_6 -# 763| r763_5(glval) = FunctionAddress[operator=] : -#-----| r0_8(glval) = VariableAddress[p#0] : -#-----| r0_9(Derived &) = Load : &:r0_8, m0_2 -#-----| r0_10(glval) = CopyValue : r0_9 -#-----| r0_11(Derived *) = CopyValue : r0_10 -#-----| r0_12(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_11 -#-----| r0_13(glval) = CopyValue : r0_12 -#-----| r0_14(Middle &) = CopyValue : r0_13 -# 763| r763_6(Middle &) = Call : func:r763_5, this:r0_7, 0:r0_14 -# 763| m763_7(unknown) = ^CallSideEffect : ~m0_5 -# 763| m763_8(unknown) = Chi : total:m0_5, partial:m763_7 -#-----| v0_15(void) = ^BufferReadSideEffect[-1] : &:r0_7, ~m763_8 -#-----| v0_16(void) = ^BufferReadSideEffect[0] : &:r0_14, ~m763_8 -#-----| m0_17(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_7 -#-----| m0_18(unknown) = Chi : total:m763_8, partial:m0_17 -#-----| m0_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_14 -#-----| m0_20(unknown) = Chi : total:m0_18, partial:m0_19 -#-----| r0_21(glval) = CopyValue : r763_6 -#-----| r0_22(Derived *) = CopyValue : r763_4 -#-----| r0_23(glval) = FieldAddress[derived_s] : r0_22 -#-----| r0_24(String *) = CopyValue : r0_23 -# 763| r763_9(glval) = FunctionAddress[operator=] : -#-----| r0_25(glval) = VariableAddress[p#0] : -#-----| r0_26(Derived &) = Load : &:r0_25, m0_2 -#-----| r0_27(glval) = CopyValue : r0_26 -#-----| r0_28(glval) = FieldAddress[derived_s] : r0_27 -#-----| r0_29(String &) = CopyValue : r0_28 -# 763| r763_10(String &) = Call : func:r763_9, this:r0_24, 0:r0_29 -# 763| m763_11(unknown) = ^CallSideEffect : ~m0_20 -# 763| m763_12(unknown) = Chi : total:m0_20, partial:m763_11 -#-----| v0_30(void) = ^BufferReadSideEffect[-1] : &:r0_24, ~m763_12 -#-----| v0_31(void) = ^BufferReadSideEffect[0] : &:r0_29, ~m763_12 -#-----| m0_32(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_24 -#-----| m0_33(unknown) = Chi : total:m763_12, partial:m0_32 -#-----| m0_34(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_29 -#-----| m0_35(unknown) = Chi : total:m0_33, partial:m0_34 -#-----| r0_36(glval) = CopyValue : r763_10 -#-----| r0_37(glval) = VariableAddress[#return] : -#-----| r0_38(Derived *) = CopyValue : r763_4 -#-----| r0_39(glval) = CopyValue : r0_38 -#-----| r0_40(Derived &) = CopyValue : r0_39 -#-----| m0_41(Derived &) = Store : &:r0_37, r0_40 -#-----| v0_42(void) = ReturnIndirection : &:r0_3, ~m0_35 -# 763| r763_13(glval) = VariableAddress[#return] : -# 763| v763_14(void) = ReturnValue : &:r763_13, m0_41 -# 763| v763_15(void) = UnmodeledUse : mu* -# 763| v763_16(void) = AliasedUse : ~m0_35 -# 763| v763_17(void) = ExitFunction : - -# 766| void Derived::Derived() -# 766| Block 0 -# 766| v766_1(void) = EnterFunction : -# 766| m766_2(unknown) = AliasedDefinition : -# 766| mu766_3(unknown) = UnmodeledDefinition : -# 766| r766_4(glval) = InitializeThis : -# 766| r766_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r766_4 -# 766| r766_6(glval) = FunctionAddress[Middle] : -# 766| v766_7(void) = Call : func:r766_6, this:r766_5 -# 766| m766_8(unknown) = ^CallSideEffect : ~m766_2 -# 766| m766_9(unknown) = Chi : total:m766_2, partial:m766_8 -# 766| m766_10(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r766_5 -# 766| m766_11(unknown) = Chi : total:m766_9, partial:m766_10 -# 766| r766_12(glval) = FieldAddress[derived_s] : r766_4 -# 766| r766_13(glval) = FunctionAddress[String] : -# 766| v766_14(void) = Call : func:r766_13, this:r766_12 -# 766| m766_15(unknown) = ^CallSideEffect : ~m766_11 -# 766| m766_16(unknown) = Chi : total:m766_11, partial:m766_15 -# 766| m766_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r766_12 -# 766| m766_18(unknown) = Chi : total:m766_16, partial:m766_17 -# 767| v767_1(void) = NoOp : -# 766| v766_19(void) = ReturnVoid : -# 766| v766_20(void) = UnmodeledUse : mu* -# 766| v766_21(void) = AliasedUse : ~m766_18 -# 766| v766_22(void) = ExitFunction : - -# 768| void Derived::~Derived() -# 768| Block 0 -# 768| v768_1(void) = EnterFunction : -# 768| m768_2(unknown) = AliasedDefinition : -# 768| mu768_3(unknown) = UnmodeledDefinition : -# 768| r768_4(glval) = InitializeThis : -# 769| v769_1(void) = NoOp : -# 769| r769_2(glval) = FieldAddress[derived_s] : r768_4 -# 769| r769_3(glval) = FunctionAddress[~String] : -# 769| v769_4(void) = Call : func:r769_3, this:r769_2 -# 769| m769_5(unknown) = ^CallSideEffect : ~m768_2 -# 769| m769_6(unknown) = Chi : total:m768_2, partial:m769_5 -# 769| r769_7(glval) = ConvertToNonVirtualBase[Derived : Middle] : r768_4 -# 769| r769_8(glval) = FunctionAddress[~Middle] : -# 769| v769_9(void) = Call : func:r769_8, this:r769_7 -# 769| m769_10(unknown) = ^CallSideEffect : ~m769_6 -# 769| m769_11(unknown) = Chi : total:m769_6, partial:m769_10 -# 768| v768_5(void) = ReturnVoid : -# 768| v768_6(void) = UnmodeledUse : mu* -# 768| v768_7(void) = AliasedUse : ~m769_11 -# 768| v768_8(void) = ExitFunction : - -# 775| void MiddleVB1::MiddleVB1() -# 775| Block 0 -# 775| v775_1(void) = EnterFunction : -# 775| m775_2(unknown) = AliasedDefinition : -# 775| mu775_3(unknown) = UnmodeledDefinition : -# 775| r775_4(glval) = InitializeThis : -# 775| r775_5(glval) = ConvertToNonVirtualBase[MiddleVB1 : Base] : r775_4 -# 775| r775_6(glval) = FunctionAddress[Base] : -# 775| v775_7(void) = Call : func:r775_6, this:r775_5 -# 775| m775_8(unknown) = ^CallSideEffect : ~m775_2 -# 775| m775_9(unknown) = Chi : total:m775_2, partial:m775_8 -# 775| m775_10(Base) = ^IndirectMayWriteSideEffect[-1] : &:r775_5 -# 775| m775_11(unknown) = Chi : total:m775_9, partial:m775_10 -# 775| r775_12(glval) = FieldAddress[middlevb1_s] : r775_4 -# 775| r775_13(glval) = FunctionAddress[String] : -# 775| v775_14(void) = Call : func:r775_13, this:r775_12 -# 775| m775_15(unknown) = ^CallSideEffect : ~m775_11 -# 775| m775_16(unknown) = Chi : total:m775_11, partial:m775_15 -# 775| m775_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r775_12 -# 775| m775_18(unknown) = Chi : total:m775_16, partial:m775_17 -# 776| v776_1(void) = NoOp : -# 775| v775_19(void) = ReturnVoid : -# 775| v775_20(void) = UnmodeledUse : mu* -# 775| v775_21(void) = AliasedUse : ~m775_18 -# 775| v775_22(void) = ExitFunction : - -# 777| void MiddleVB1::~MiddleVB1() -# 777| Block 0 -# 777| v777_1(void) = EnterFunction : -# 777| m777_2(unknown) = AliasedDefinition : -# 777| mu777_3(unknown) = UnmodeledDefinition : -# 777| r777_4(glval) = InitializeThis : -# 778| v778_1(void) = NoOp : -# 778| r778_2(glval) = FieldAddress[middlevb1_s] : r777_4 -# 778| r778_3(glval) = FunctionAddress[~String] : -# 778| v778_4(void) = Call : func:r778_3, this:r778_2 -# 778| m778_5(unknown) = ^CallSideEffect : ~m777_2 -# 778| m778_6(unknown) = Chi : total:m777_2, partial:m778_5 -# 778| r778_7(glval) = ConvertToNonVirtualBase[MiddleVB1 : Base] : r777_4 -# 778| r778_8(glval) = FunctionAddress[~Base] : -# 778| v778_9(void) = Call : func:r778_8, this:r778_7 -# 778| m778_10(unknown) = ^CallSideEffect : ~m778_6 -# 778| m778_11(unknown) = Chi : total:m778_6, partial:m778_10 -# 777| v777_5(void) = ReturnVoid : -# 777| v777_6(void) = UnmodeledUse : mu* -# 777| v777_7(void) = AliasedUse : ~m778_11 -# 777| v777_8(void) = ExitFunction : - -# 784| void MiddleVB2::MiddleVB2() -# 784| Block 0 -# 784| v784_1(void) = EnterFunction : -# 784| m784_2(unknown) = AliasedDefinition : -# 784| mu784_3(unknown) = UnmodeledDefinition : -# 784| r784_4(glval) = InitializeThis : -# 784| r784_5(glval) = ConvertToNonVirtualBase[MiddleVB2 : Base] : r784_4 -# 784| r784_6(glval) = FunctionAddress[Base] : -# 784| v784_7(void) = Call : func:r784_6, this:r784_5 -# 784| m784_8(unknown) = ^CallSideEffect : ~m784_2 -# 784| m784_9(unknown) = Chi : total:m784_2, partial:m784_8 -# 784| m784_10(Base) = ^IndirectMayWriteSideEffect[-1] : &:r784_5 -# 784| m784_11(unknown) = Chi : total:m784_9, partial:m784_10 -# 784| r784_12(glval) = FieldAddress[middlevb2_s] : r784_4 -# 784| r784_13(glval) = FunctionAddress[String] : -# 784| v784_14(void) = Call : func:r784_13, this:r784_12 -# 784| m784_15(unknown) = ^CallSideEffect : ~m784_11 -# 784| m784_16(unknown) = Chi : total:m784_11, partial:m784_15 -# 784| m784_17(String) = ^IndirectMayWriteSideEffect[-1] : &:r784_12 -# 784| m784_18(unknown) = Chi : total:m784_16, partial:m784_17 -# 785| v785_1(void) = NoOp : -# 784| v784_19(void) = ReturnVoid : -# 784| v784_20(void) = UnmodeledUse : mu* -# 784| v784_21(void) = AliasedUse : ~m784_18 -# 784| v784_22(void) = ExitFunction : - -# 786| void MiddleVB2::~MiddleVB2() -# 786| Block 0 -# 786| v786_1(void) = EnterFunction : -# 786| m786_2(unknown) = AliasedDefinition : -# 786| mu786_3(unknown) = UnmodeledDefinition : -# 786| r786_4(glval) = InitializeThis : -# 787| v787_1(void) = NoOp : -# 787| r787_2(glval) = FieldAddress[middlevb2_s] : r786_4 -# 787| r787_3(glval) = FunctionAddress[~String] : -# 787| v787_4(void) = Call : func:r787_3, this:r787_2 -# 787| m787_5(unknown) = ^CallSideEffect : ~m786_2 -# 787| m787_6(unknown) = Chi : total:m786_2, partial:m787_5 -# 787| r787_7(glval) = ConvertToNonVirtualBase[MiddleVB2 : Base] : r786_4 -# 787| r787_8(glval) = FunctionAddress[~Base] : -# 787| v787_9(void) = Call : func:r787_8, this:r787_7 -# 787| m787_10(unknown) = ^CallSideEffect : ~m787_6 -# 787| m787_11(unknown) = Chi : total:m787_6, partial:m787_10 -# 786| v786_5(void) = ReturnVoid : -# 786| v786_6(void) = UnmodeledUse : mu* -# 786| v786_7(void) = AliasedUse : ~m787_11 -# 786| v786_8(void) = ExitFunction : - -# 793| void DerivedVB::DerivedVB() -# 793| Block 0 -# 793| v793_1(void) = EnterFunction : -# 793| m793_2(unknown) = AliasedDefinition : -# 793| mu793_3(unknown) = UnmodeledDefinition : -# 793| r793_4(glval) = InitializeThis : -# 793| r793_5(glval) = ConvertToNonVirtualBase[DerivedVB : Base] : r793_4 -# 793| r793_6(glval) = FunctionAddress[Base] : -# 793| v793_7(void) = Call : func:r793_6, this:r793_5 -# 793| m793_8(unknown) = ^CallSideEffect : ~m793_2 -# 793| m793_9(unknown) = Chi : total:m793_2, partial:m793_8 -# 793| m793_10(Base) = ^IndirectMayWriteSideEffect[-1] : &:r793_5 -# 793| m793_11(unknown) = Chi : total:m793_9, partial:m793_10 -# 793| r793_12(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB1] : r793_4 -# 793| r793_13(glval) = FunctionAddress[MiddleVB1] : -# 793| v793_14(void) = Call : func:r793_13, this:r793_12 -# 793| m793_15(unknown) = ^CallSideEffect : ~m793_11 -# 793| m793_16(unknown) = Chi : total:m793_11, partial:m793_15 -# 793| m793_17(MiddleVB1) = ^IndirectMayWriteSideEffect[-1] : &:r793_12 -# 793| m793_18(unknown) = Chi : total:m793_16, partial:m793_17 -# 793| r793_19(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB2] : r793_4 -# 793| r793_20(glval) = FunctionAddress[MiddleVB2] : -# 793| v793_21(void) = Call : func:r793_20, this:r793_19 -# 793| m793_22(unknown) = ^CallSideEffect : ~m793_18 -# 793| m793_23(unknown) = Chi : total:m793_18, partial:m793_22 -# 793| m793_24(MiddleVB2) = ^IndirectMayWriteSideEffect[-1] : &:r793_19 -# 793| m793_25(unknown) = Chi : total:m793_23, partial:m793_24 -# 793| r793_26(glval) = FieldAddress[derivedvb_s] : r793_4 -# 793| r793_27(glval) = FunctionAddress[String] : -# 793| v793_28(void) = Call : func:r793_27, this:r793_26 -# 793| m793_29(unknown) = ^CallSideEffect : ~m793_25 -# 793| m793_30(unknown) = Chi : total:m793_25, partial:m793_29 -# 793| m793_31(String) = ^IndirectMayWriteSideEffect[-1] : &:r793_26 -# 793| m793_32(unknown) = Chi : total:m793_30, partial:m793_31 -# 794| v794_1(void) = NoOp : -# 793| v793_33(void) = ReturnVoid : -# 793| v793_34(void) = UnmodeledUse : mu* -# 793| v793_35(void) = AliasedUse : ~m793_32 -# 793| v793_36(void) = ExitFunction : - -# 795| void DerivedVB::~DerivedVB() -# 795| Block 0 -# 795| v795_1(void) = EnterFunction : -# 795| m795_2(unknown) = AliasedDefinition : -# 795| mu795_3(unknown) = UnmodeledDefinition : -# 795| r795_4(glval) = InitializeThis : -# 796| v796_1(void) = NoOp : -# 796| r796_2(glval) = FieldAddress[derivedvb_s] : r795_4 -# 796| r796_3(glval) = FunctionAddress[~String] : -# 796| v796_4(void) = Call : func:r796_3, this:r796_2 -# 796| m796_5(unknown) = ^CallSideEffect : ~m795_2 -# 796| m796_6(unknown) = Chi : total:m795_2, partial:m796_5 -# 796| r796_7(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB2] : r795_4 -# 796| r796_8(glval) = FunctionAddress[~MiddleVB2] : -# 796| v796_9(void) = Call : func:r796_8, this:r796_7 -# 796| m796_10(unknown) = ^CallSideEffect : ~m796_6 -# 796| m796_11(unknown) = Chi : total:m796_6, partial:m796_10 -# 796| r796_12(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB1] : r795_4 -# 796| r796_13(glval) = FunctionAddress[~MiddleVB1] : -# 796| v796_14(void) = Call : func:r796_13, this:r796_12 -# 796| m796_15(unknown) = ^CallSideEffect : ~m796_11 -# 796| m796_16(unknown) = Chi : total:m796_11, partial:m796_15 -# 796| r796_17(glval) = ConvertToNonVirtualBase[DerivedVB : Base] : r795_4 -# 796| r796_18(glval) = FunctionAddress[~Base] : -# 796| v796_19(void) = Call : func:r796_18, this:r796_17 -# 796| m796_20(unknown) = ^CallSideEffect : ~m796_16 -# 796| m796_21(unknown) = Chi : total:m796_16, partial:m796_20 -# 795| v795_5(void) = ReturnVoid : -# 795| v795_6(void) = UnmodeledUse : mu* -# 795| v795_7(void) = AliasedUse : ~m796_21 -# 795| v795_8(void) = ExitFunction : - -# 799| void HierarchyConversions() -# 799| Block 0 -# 799| v799_1(void) = EnterFunction : -# 799| m799_2(unknown) = AliasedDefinition : -# 799| mu799_3(unknown) = UnmodeledDefinition : -# 800| r800_1(glval) = VariableAddress[b] : -# 800| m800_2(Base) = Uninitialized[b] : &:r800_1 -# 800| r800_3(glval) = FunctionAddress[Base] : -# 800| v800_4(void) = Call : func:r800_3, this:r800_1 -# 800| m800_5(unknown) = ^CallSideEffect : ~m799_2 -# 800| m800_6(unknown) = Chi : total:m799_2, partial:m800_5 -# 800| m800_7(Base) = ^IndirectMayWriteSideEffect[-1] : &:r800_1 -# 800| m800_8(Base) = Chi : total:m800_2, partial:m800_7 -# 801| r801_1(glval) = VariableAddress[m] : -# 801| m801_2(Middle) = Uninitialized[m] : &:r801_1 -# 801| r801_3(glval) = FunctionAddress[Middle] : -# 801| v801_4(void) = Call : func:r801_3, this:r801_1 -# 801| m801_5(unknown) = ^CallSideEffect : ~m800_6 -# 801| m801_6(unknown) = Chi : total:m800_6, partial:m801_5 -# 801| m801_7(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r801_1 -# 801| m801_8(Middle) = Chi : total:m801_2, partial:m801_7 -# 802| r802_1(glval) = VariableAddress[d] : -# 802| m802_2(Derived) = Uninitialized[d] : &:r802_1 -# 802| r802_3(glval) = FunctionAddress[Derived] : -# 802| v802_4(void) = Call : func:r802_3, this:r802_1 -# 802| m802_5(unknown) = ^CallSideEffect : ~m801_6 -# 802| m802_6(unknown) = Chi : total:m801_6, partial:m802_5 -# 802| m802_7(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r802_1 -# 802| m802_8(Derived) = Chi : total:m802_2, partial:m802_7 -# 804| r804_1(glval) = VariableAddress[pb] : -# 804| r804_2(glval) = VariableAddress[b] : -# 804| r804_3(Base *) = CopyValue : r804_2 -# 804| m804_4(Base *) = Store : &:r804_1, r804_3 -# 805| r805_1(glval) = VariableAddress[pm] : -# 805| r805_2(glval) = VariableAddress[m] : -# 805| r805_3(Middle *) = CopyValue : r805_2 -# 805| m805_4(Middle *) = Store : &:r805_1, r805_3 -# 806| r806_1(glval) = VariableAddress[pd] : -# 806| r806_2(glval) = VariableAddress[d] : -# 806| r806_3(Derived *) = CopyValue : r806_2 -# 806| m806_4(Derived *) = Store : &:r806_1, r806_3 -# 808| r808_1(glval) = VariableAddress[b] : -# 808| r808_2(glval) = FunctionAddress[operator=] : -# 808| r808_3(glval) = VariableAddress[m] : -# 808| r808_4(glval) = ConvertToNonVirtualBase[Middle : Base] : r808_3 -# 808| r808_5(Base &) = CopyValue : r808_4 -# 808| r808_6(Base &) = Call : func:r808_2, this:r808_1, 0:r808_5 -# 808| m808_7(unknown) = ^CallSideEffect : ~m802_6 -# 808| m808_8(unknown) = Chi : total:m802_6, partial:m808_7 -# 808| v808_9(void) = ^BufferReadSideEffect[-1] : &:r808_1, ~m800_8 -# 808| v808_10(void) = ^BufferReadSideEffect[0] : &:r808_5, ~m801_8 -# 808| m808_11(Base) = ^IndirectMayWriteSideEffect[-1] : &:r808_1 -# 808| m808_12(Base) = Chi : total:m800_8, partial:m808_11 -# 808| m808_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r808_5 -# 808| m808_14(Middle) = Chi : total:m801_8, partial:m808_13 -# 808| r808_15(glval) = CopyValue : r808_6 -# 809| r809_1(glval) = VariableAddress[b] : -# 809| r809_2(glval) = FunctionAddress[operator=] : -# 809| r809_3(glval) = FunctionAddress[Base] : -# 809| r809_4(glval) = VariableAddress[m] : -# 809| r809_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r809_4 -# 809| r809_6(Base &) = CopyValue : r809_5 -# 809| v809_7(void) = Call : func:r809_3, 0:r809_6 -# 809| m809_8(unknown) = ^CallSideEffect : ~m808_8 -# 809| m809_9(unknown) = Chi : total:m808_8, partial:m809_8 -# 809| m809_10(Base) = ^IndirectMayWriteSideEffect[-1] : -# 809| m809_11(unknown) = Chi : total:m809_9, partial:m809_10 -# 809| v809_12(void) = ^BufferReadSideEffect[0] : &:r809_6, ~m808_14 -# 809| m809_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r809_6 -# 809| m809_14(Middle) = Chi : total:m808_14, partial:m809_13 -# 809| r809_15(glval) = Convert : v809_7 -# 809| r809_16(Base &) = CopyValue : r809_15 -# 809| r809_17(Base &) = Call : func:r809_2, this:r809_1, 0:r809_16 -# 809| m809_18(unknown) = ^CallSideEffect : ~m809_11 -# 809| m809_19(unknown) = Chi : total:m809_11, partial:m809_18 -# 809| v809_20(void) = ^BufferReadSideEffect[-1] : &:r809_1, ~m808_12 -# 809| v809_21(void) = ^BufferReadSideEffect[0] : &:r809_16, ~m809_19 -# 809| m809_22(Base) = ^IndirectMayWriteSideEffect[-1] : &:r809_1 -# 809| m809_23(Base) = Chi : total:m808_12, partial:m809_22 -# 809| m809_24(unknown) = ^BufferMayWriteSideEffect[0] : &:r809_16 -# 809| m809_25(unknown) = Chi : total:m809_19, partial:m809_24 -# 809| r809_26(glval) = CopyValue : r809_17 -# 810| r810_1(glval) = VariableAddress[b] : -# 810| r810_2(glval) = FunctionAddress[operator=] : -# 810| r810_3(glval) = FunctionAddress[Base] : -# 810| r810_4(glval) = VariableAddress[m] : -# 810| r810_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r810_4 -# 810| r810_6(Base &) = CopyValue : r810_5 -# 810| v810_7(void) = Call : func:r810_3, 0:r810_6 -# 810| m810_8(unknown) = ^CallSideEffect : ~m809_25 -# 810| m810_9(unknown) = Chi : total:m809_25, partial:m810_8 -# 810| m810_10(Base) = ^IndirectMayWriteSideEffect[-1] : -# 810| m810_11(unknown) = Chi : total:m810_9, partial:m810_10 -# 810| v810_12(void) = ^BufferReadSideEffect[0] : &:r810_6, ~m809_14 -# 810| m810_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r810_6 -# 810| m810_14(Middle) = Chi : total:m809_14, partial:m810_13 -# 810| r810_15(glval) = Convert : v810_7 -# 810| r810_16(Base &) = CopyValue : r810_15 -# 810| r810_17(Base &) = Call : func:r810_2, this:r810_1, 0:r810_16 -# 810| m810_18(unknown) = ^CallSideEffect : ~m810_11 -# 810| m810_19(unknown) = Chi : total:m810_11, partial:m810_18 -# 810| v810_20(void) = ^BufferReadSideEffect[-1] : &:r810_1, ~m809_23 -# 810| v810_21(void) = ^BufferReadSideEffect[0] : &:r810_16, ~m810_19 -# 810| m810_22(Base) = ^IndirectMayWriteSideEffect[-1] : &:r810_1 -# 810| m810_23(Base) = Chi : total:m809_23, partial:m810_22 -# 810| m810_24(unknown) = ^BufferMayWriteSideEffect[0] : &:r810_16 -# 810| m810_25(unknown) = Chi : total:m810_19, partial:m810_24 -# 810| r810_26(glval) = CopyValue : r810_17 -# 811| r811_1(glval) = VariableAddress[pm] : -# 811| r811_2(Middle *) = Load : &:r811_1, m805_4 -# 811| r811_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r811_2 -# 811| r811_4(glval) = VariableAddress[pb] : -# 811| m811_5(Base *) = Store : &:r811_4, r811_3 -# 812| r812_1(glval) = VariableAddress[pm] : -# 812| r812_2(Middle *) = Load : &:r812_1, m805_4 -# 812| r812_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r812_2 -# 812| r812_4(glval) = VariableAddress[pb] : -# 812| m812_5(Base *) = Store : &:r812_4, r812_3 -# 813| r813_1(glval) = VariableAddress[pm] : -# 813| r813_2(Middle *) = Load : &:r813_1, m805_4 -# 813| r813_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r813_2 -# 813| r813_4(glval) = VariableAddress[pb] : -# 813| m813_5(Base *) = Store : &:r813_4, r813_3 -# 814| r814_1(glval) = VariableAddress[pm] : -# 814| r814_2(Middle *) = Load : &:r814_1, m805_4 -# 814| r814_3(Base *) = Convert : r814_2 -# 814| r814_4(glval) = VariableAddress[pb] : -# 814| m814_5(Base *) = Store : &:r814_4, r814_3 -# 816| r816_1(glval) = VariableAddress[m] : -# 816| r816_2(glval) = FunctionAddress[operator=] : -# 816| r816_3(glval) = VariableAddress[b] : -# 816| r816_4(glval) = ConvertToDerived[Middle : Base] : r816_3 -# 816| r816_5(glval) = Convert : r816_4 -# 816| r816_6(Middle &) = CopyValue : r816_5 -# 816| r816_7(Middle &) = Call : func:r816_2, this:r816_1, 0:r816_6 -# 816| m816_8(unknown) = ^CallSideEffect : ~m810_25 -# 816| m816_9(unknown) = Chi : total:m810_25, partial:m816_8 -# 816| v816_10(void) = ^BufferReadSideEffect[-1] : &:r816_1, ~m810_14 -# 816| v816_11(void) = ^BufferReadSideEffect[0] : &:r816_6, ~m810_23 -# 816| m816_12(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r816_1 -# 816| m816_13(Middle) = Chi : total:m810_14, partial:m816_12 -# 816| m816_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r816_6 -# 816| m816_15(Base) = Chi : total:m810_23, partial:m816_14 -# 816| r816_16(glval) = CopyValue : r816_7 -# 817| r817_1(glval) = VariableAddress[m] : -# 817| r817_2(glval) = FunctionAddress[operator=] : -# 817| r817_3(glval) = VariableAddress[b] : -# 817| r817_4(glval) = ConvertToDerived[Middle : Base] : r817_3 -# 817| r817_5(glval) = Convert : r817_4 -# 817| r817_6(Middle &) = CopyValue : r817_5 -# 817| r817_7(Middle &) = Call : func:r817_2, this:r817_1, 0:r817_6 -# 817| m817_8(unknown) = ^CallSideEffect : ~m816_9 -# 817| m817_9(unknown) = Chi : total:m816_9, partial:m817_8 -# 817| v817_10(void) = ^BufferReadSideEffect[-1] : &:r817_1, ~m816_13 -# 817| v817_11(void) = ^BufferReadSideEffect[0] : &:r817_6, ~m816_15 -# 817| m817_12(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r817_1 -# 817| m817_13(Middle) = Chi : total:m816_13, partial:m817_12 -# 817| m817_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r817_6 -# 817| m817_15(Base) = Chi : total:m816_15, partial:m817_14 -# 817| r817_16(glval) = CopyValue : r817_7 -# 818| r818_1(glval) = VariableAddress[pb] : -# 818| r818_2(Base *) = Load : &:r818_1, m814_5 -# 818| r818_3(Middle *) = ConvertToDerived[Middle : Base] : r818_2 -# 818| r818_4(glval) = VariableAddress[pm] : -# 818| m818_5(Middle *) = Store : &:r818_4, r818_3 -# 819| r819_1(glval) = VariableAddress[pb] : -# 819| r819_2(Base *) = Load : &:r819_1, m814_5 -# 819| r819_3(Middle *) = ConvertToDerived[Middle : Base] : r819_2 -# 819| r819_4(glval) = VariableAddress[pm] : -# 819| m819_5(Middle *) = Store : &:r819_4, r819_3 -# 820| r820_1(glval) = VariableAddress[pb] : -# 820| r820_2(Base *) = Load : &:r820_1, m814_5 -# 820| r820_3(Middle *) = Convert : r820_2 -# 820| r820_4(glval) = VariableAddress[pm] : -# 820| m820_5(Middle *) = Store : &:r820_4, r820_3 -# 822| r822_1(glval) = VariableAddress[b] : -# 822| r822_2(glval) = FunctionAddress[operator=] : -# 822| r822_3(glval) = VariableAddress[d] : -# 822| r822_4(glval) = ConvertToNonVirtualBase[Derived : Middle] : r822_3 -# 822| r822_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r822_4 -# 822| r822_6(Base &) = CopyValue : r822_5 -# 822| r822_7(Base &) = Call : func:r822_2, this:r822_1, 0:r822_6 -# 822| m822_8(unknown) = ^CallSideEffect : ~m817_9 -# 822| m822_9(unknown) = Chi : total:m817_9, partial:m822_8 -# 822| v822_10(void) = ^BufferReadSideEffect[-1] : &:r822_1, ~m817_15 -# 822| v822_11(void) = ^BufferReadSideEffect[0] : &:r822_6, ~m802_8 -# 822| m822_12(Base) = ^IndirectMayWriteSideEffect[-1] : &:r822_1 -# 822| m822_13(Base) = Chi : total:m817_15, partial:m822_12 -# 822| m822_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r822_6 -# 822| m822_15(Derived) = Chi : total:m802_8, partial:m822_14 -# 822| r822_16(glval) = CopyValue : r822_7 -# 823| r823_1(glval) = VariableAddress[b] : -# 823| r823_2(glval) = FunctionAddress[operator=] : -# 823| r823_3(glval) = FunctionAddress[Base] : -# 823| r823_4(glval) = VariableAddress[d] : -# 823| r823_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r823_4 -# 823| r823_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r823_5 -# 823| r823_7(Base &) = CopyValue : r823_6 -# 823| v823_8(void) = Call : func:r823_3, 0:r823_7 -# 823| m823_9(unknown) = ^CallSideEffect : ~m822_9 -# 823| m823_10(unknown) = Chi : total:m822_9, partial:m823_9 -# 823| m823_11(Base) = ^IndirectMayWriteSideEffect[-1] : -# 823| m823_12(unknown) = Chi : total:m823_10, partial:m823_11 -# 823| v823_13(void) = ^BufferReadSideEffect[0] : &:r823_7, ~m822_15 -# 823| m823_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r823_7 -# 823| m823_15(Derived) = Chi : total:m822_15, partial:m823_14 -# 823| r823_16(glval) = Convert : v823_8 -# 823| r823_17(Base &) = CopyValue : r823_16 -# 823| r823_18(Base &) = Call : func:r823_2, this:r823_1, 0:r823_17 -# 823| m823_19(unknown) = ^CallSideEffect : ~m823_12 -# 823| m823_20(unknown) = Chi : total:m823_12, partial:m823_19 -# 823| v823_21(void) = ^BufferReadSideEffect[-1] : &:r823_1, ~m822_13 -# 823| v823_22(void) = ^BufferReadSideEffect[0] : &:r823_17, ~m823_20 -# 823| m823_23(Base) = ^IndirectMayWriteSideEffect[-1] : &:r823_1 -# 823| m823_24(Base) = Chi : total:m822_13, partial:m823_23 -# 823| m823_25(unknown) = ^BufferMayWriteSideEffect[0] : &:r823_17 -# 823| m823_26(unknown) = Chi : total:m823_20, partial:m823_25 -# 823| r823_27(glval) = CopyValue : r823_18 -# 824| r824_1(glval) = VariableAddress[b] : -# 824| r824_2(glval) = FunctionAddress[operator=] : -# 824| r824_3(glval) = FunctionAddress[Base] : -# 824| r824_4(glval) = VariableAddress[d] : -# 824| r824_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r824_4 -# 824| r824_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r824_5 -# 824| r824_7(Base &) = CopyValue : r824_6 -# 824| v824_8(void) = Call : func:r824_3, 0:r824_7 -# 824| m824_9(unknown) = ^CallSideEffect : ~m823_26 -# 824| m824_10(unknown) = Chi : total:m823_26, partial:m824_9 -# 824| m824_11(Base) = ^IndirectMayWriteSideEffect[-1] : -# 824| m824_12(unknown) = Chi : total:m824_10, partial:m824_11 -# 824| v824_13(void) = ^BufferReadSideEffect[0] : &:r824_7, ~m823_15 -# 824| m824_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r824_7 -# 824| m824_15(Derived) = Chi : total:m823_15, partial:m824_14 -# 824| r824_16(glval) = Convert : v824_8 -# 824| r824_17(Base &) = CopyValue : r824_16 -# 824| r824_18(Base &) = Call : func:r824_2, this:r824_1, 0:r824_17 -# 824| m824_19(unknown) = ^CallSideEffect : ~m824_12 -# 824| m824_20(unknown) = Chi : total:m824_12, partial:m824_19 -# 824| v824_21(void) = ^BufferReadSideEffect[-1] : &:r824_1, ~m823_24 -# 824| v824_22(void) = ^BufferReadSideEffect[0] : &:r824_17, ~m824_20 -# 824| m824_23(Base) = ^IndirectMayWriteSideEffect[-1] : &:r824_1 -# 824| m824_24(Base) = Chi : total:m823_24, partial:m824_23 -# 824| m824_25(unknown) = ^BufferMayWriteSideEffect[0] : &:r824_17 -# 824| m824_26(unknown) = Chi : total:m824_20, partial:m824_25 -# 824| r824_27(glval) = CopyValue : r824_18 -# 825| r825_1(glval) = VariableAddress[pd] : -# 825| r825_2(Derived *) = Load : &:r825_1, m806_4 -# 825| r825_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r825_2 -# 825| r825_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r825_3 -# 825| r825_5(glval) = VariableAddress[pb] : -# 825| m825_6(Base *) = Store : &:r825_5, r825_4 -# 826| r826_1(glval) = VariableAddress[pd] : -# 826| r826_2(Derived *) = Load : &:r826_1, m806_4 -# 826| r826_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r826_2 -# 826| r826_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r826_3 -# 826| r826_5(glval) = VariableAddress[pb] : -# 826| m826_6(Base *) = Store : &:r826_5, r826_4 -# 827| r827_1(glval) = VariableAddress[pd] : -# 827| r827_2(Derived *) = Load : &:r827_1, m806_4 -# 827| r827_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r827_2 -# 827| r827_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r827_3 -# 827| r827_5(glval) = VariableAddress[pb] : -# 827| m827_6(Base *) = Store : &:r827_5, r827_4 -# 828| r828_1(glval) = VariableAddress[pd] : -# 828| r828_2(Derived *) = Load : &:r828_1, m806_4 -# 828| r828_3(Base *) = Convert : r828_2 -# 828| r828_4(glval) = VariableAddress[pb] : -# 828| m828_5(Base *) = Store : &:r828_4, r828_3 -# 830| r830_1(glval) = VariableAddress[d] : -# 830| r830_2(glval) = FunctionAddress[operator=] : -# 830| r830_3(glval) = VariableAddress[b] : -# 830| r830_4(glval) = ConvertToDerived[Middle : Base] : r830_3 -# 830| r830_5(glval) = ConvertToDerived[Derived : Middle] : r830_4 -# 830| r830_6(glval) = Convert : r830_5 -# 830| r830_7(Derived &) = CopyValue : r830_6 -# 830| r830_8(Derived &) = Call : func:r830_2, this:r830_1, 0:r830_7 -# 830| m830_9(unknown) = ^CallSideEffect : ~m824_26 -# 830| m830_10(unknown) = Chi : total:m824_26, partial:m830_9 -# 830| v830_11(void) = ^BufferReadSideEffect[-1] : &:r830_1, ~m824_15 -# 830| v830_12(void) = ^BufferReadSideEffect[0] : &:r830_7, ~m824_24 -# 830| m830_13(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r830_1 -# 830| m830_14(Derived) = Chi : total:m824_15, partial:m830_13 -# 830| m830_15(unknown) = ^BufferMayWriteSideEffect[0] : &:r830_7 -# 830| m830_16(Base) = Chi : total:m824_24, partial:m830_15 -# 830| r830_17(glval) = CopyValue : r830_8 -# 831| r831_1(glval) = VariableAddress[d] : -# 831| r831_2(glval) = FunctionAddress[operator=] : -# 831| r831_3(glval) = VariableAddress[b] : -# 831| r831_4(glval) = ConvertToDerived[Middle : Base] : r831_3 -# 831| r831_5(glval) = ConvertToDerived[Derived : Middle] : r831_4 -# 831| r831_6(glval) = Convert : r831_5 -# 831| r831_7(Derived &) = CopyValue : r831_6 -# 831| r831_8(Derived &) = Call : func:r831_2, this:r831_1, 0:r831_7 -# 831| m831_9(unknown) = ^CallSideEffect : ~m830_10 -# 831| m831_10(unknown) = Chi : total:m830_10, partial:m831_9 -# 831| v831_11(void) = ^BufferReadSideEffect[-1] : &:r831_1, ~m830_14 -# 831| v831_12(void) = ^BufferReadSideEffect[0] : &:r831_7, ~m830_16 -# 831| m831_13(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r831_1 -# 831| m831_14(Derived) = Chi : total:m830_14, partial:m831_13 -# 831| m831_15(unknown) = ^BufferMayWriteSideEffect[0] : &:r831_7 -# 831| m831_16(Base) = Chi : total:m830_16, partial:m831_15 -# 831| r831_17(glval) = CopyValue : r831_8 -# 832| r832_1(glval) = VariableAddress[pb] : -# 832| r832_2(Base *) = Load : &:r832_1, m828_5 -# 832| r832_3(Middle *) = ConvertToDerived[Middle : Base] : r832_2 -# 832| r832_4(Derived *) = ConvertToDerived[Derived : Middle] : r832_3 -# 832| r832_5(glval) = VariableAddress[pd] : -# 832| m832_6(Derived *) = Store : &:r832_5, r832_4 -# 833| r833_1(glval) = VariableAddress[pb] : -# 833| r833_2(Base *) = Load : &:r833_1, m828_5 -# 833| r833_3(Middle *) = ConvertToDerived[Middle : Base] : r833_2 -# 833| r833_4(Derived *) = ConvertToDerived[Derived : Middle] : r833_3 -# 833| r833_5(glval) = VariableAddress[pd] : -# 833| m833_6(Derived *) = Store : &:r833_5, r833_4 -# 834| r834_1(glval) = VariableAddress[pb] : -# 834| r834_2(Base *) = Load : &:r834_1, m828_5 -# 834| r834_3(Derived *) = Convert : r834_2 -# 834| r834_4(glval) = VariableAddress[pd] : -# 834| m834_5(Derived *) = Store : &:r834_4, r834_3 -# 836| r836_1(glval) = VariableAddress[pmv] : -# 836| r836_2(MiddleVB1 *) = Constant[0] : -# 836| m836_3(MiddleVB1 *) = Store : &:r836_1, r836_2 -# 837| r837_1(glval) = VariableAddress[pdv] : -# 837| r837_2(DerivedVB *) = Constant[0] : -# 837| m837_3(DerivedVB *) = Store : &:r837_1, r837_2 -# 838| r838_1(glval) = VariableAddress[pmv] : -# 838| r838_2(MiddleVB1 *) = Load : &:r838_1, m836_3 -# 838| r838_3(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r838_2 -# 838| r838_4(glval) = VariableAddress[pb] : -# 838| m838_5(Base *) = Store : &:r838_4, r838_3 -# 839| r839_1(glval) = VariableAddress[pdv] : -# 839| r839_2(DerivedVB *) = Load : &:r839_1, m837_3 -# 839| r839_3(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r839_2 -# 839| r839_4(glval) = VariableAddress[pb] : -# 839| m839_5(Base *) = Store : &:r839_4, r839_3 -# 840| v840_1(void) = NoOp : -# 799| v799_4(void) = ReturnVoid : -# 799| v799_5(void) = UnmodeledUse : mu* -# 799| v799_6(void) = AliasedUse : ~m831_10 -# 799| v799_7(void) = ExitFunction : - -# 842| void PolymorphicBase::PolymorphicBase() -# 842| Block 0 -# 842| v842_1(void) = EnterFunction : -# 842| m842_2(unknown) = AliasedDefinition : -# 842| mu842_3(unknown) = UnmodeledDefinition : -# 842| r842_4(glval) = InitializeThis : -# 842| v842_5(void) = NoOp : -# 842| v842_6(void) = ReturnVoid : -# 842| v842_7(void) = UnmodeledUse : mu* -# 842| v842_8(void) = AliasedUse : ~m842_2 -# 842| v842_9(void) = ExitFunction : - -# 846| void PolymorphicDerived::PolymorphicDerived() -# 846| Block 0 -# 846| v846_1(void) = EnterFunction : -# 846| m846_2(unknown) = AliasedDefinition : -# 846| mu846_3(unknown) = UnmodeledDefinition : -# 846| r846_4(glval) = InitializeThis : -# 846| r846_5(glval) = ConvertToNonVirtualBase[PolymorphicDerived : PolymorphicBase] : r846_4 -# 846| r846_6(glval) = FunctionAddress[PolymorphicBase] : -# 846| v846_7(void) = Call : func:r846_6, this:r846_5 -# 846| m846_8(unknown) = ^CallSideEffect : ~m846_2 -# 846| m846_9(unknown) = Chi : total:m846_2, partial:m846_8 -# 846| m846_10(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r846_5 -# 846| m846_11(unknown) = Chi : total:m846_9, partial:m846_10 -# 846| v846_12(void) = NoOp : -# 846| v846_13(void) = ReturnVoid : -# 846| v846_14(void) = UnmodeledUse : mu* -# 846| v846_15(void) = AliasedUse : ~m846_11 -# 846| v846_16(void) = ExitFunction : - -# 846| void PolymorphicDerived::~PolymorphicDerived() -# 846| Block 0 -# 846| v846_1(void) = EnterFunction : -# 846| m846_2(unknown) = AliasedDefinition : -# 846| mu846_3(unknown) = UnmodeledDefinition : -# 846| r846_4(glval) = InitializeThis : -#-----| v0_1(void) = NoOp : -# 846| r846_5(glval) = ConvertToNonVirtualBase[PolymorphicDerived : PolymorphicBase] : r846_4 -# 846| r846_6(glval) = FunctionAddress[~PolymorphicBase] : -# 846| v846_7(void) = Call : func:r846_6, this:r846_5 -# 846| m846_8(unknown) = ^CallSideEffect : ~m846_2 -# 846| m846_9(unknown) = Chi : total:m846_2, partial:m846_8 -# 846| v846_10(void) = ReturnVoid : -# 846| v846_11(void) = UnmodeledUse : mu* -# 846| v846_12(void) = AliasedUse : ~m846_9 -# 846| v846_13(void) = ExitFunction : - -# 849| void DynamicCast() -# 849| Block 0 -# 849| v849_1(void) = EnterFunction : -# 849| m849_2(unknown) = AliasedDefinition : -# 849| mu849_3(unknown) = UnmodeledDefinition : -# 850| r850_1(glval) = VariableAddress[b] : -# 850| m850_2(PolymorphicBase) = Uninitialized[b] : &:r850_1 -#-----| r0_1(glval) = FunctionAddress[PolymorphicBase] : -#-----| v0_2(void) = Call : func:r0_1, this:r850_1 -#-----| m0_3(unknown) = ^CallSideEffect : ~m849_2 -#-----| m0_4(unknown) = Chi : total:m849_2, partial:m0_3 -#-----| m0_5(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r850_1 -#-----| m0_6(PolymorphicBase) = Chi : total:m850_2, partial:m0_5 -# 851| r851_1(glval) = VariableAddress[d] : -# 851| m851_2(PolymorphicDerived) = Uninitialized[d] : &:r851_1 -# 851| r851_3(glval) = FunctionAddress[PolymorphicDerived] : -# 851| v851_4(void) = Call : func:r851_3, this:r851_1 -# 851| m851_5(unknown) = ^CallSideEffect : ~m0_4 -# 851| m851_6(unknown) = Chi : total:m0_4, partial:m851_5 -# 851| m851_7(PolymorphicDerived) = ^IndirectMayWriteSideEffect[-1] : &:r851_1 -# 851| m851_8(PolymorphicDerived) = Chi : total:m851_2, partial:m851_7 -# 853| r853_1(glval) = VariableAddress[pb] : -# 853| r853_2(glval) = VariableAddress[b] : -# 853| r853_3(PolymorphicBase *) = CopyValue : r853_2 -# 853| m853_4(PolymorphicBase *) = Store : &:r853_1, r853_3 -# 854| r854_1(glval) = VariableAddress[pd] : -# 854| r854_2(glval) = VariableAddress[d] : -# 854| r854_3(PolymorphicDerived *) = CopyValue : r854_2 -# 854| m854_4(PolymorphicDerived *) = Store : &:r854_1, r854_3 -# 857| r857_1(glval) = VariableAddress[pd] : -# 857| r857_2(PolymorphicDerived *) = Load : &:r857_1, m854_4 -# 857| r857_3(PolymorphicBase *) = CheckedConvertOrNull : r857_2 -# 857| r857_4(glval) = VariableAddress[pb] : -# 857| m857_5(PolymorphicBase *) = Store : &:r857_4, r857_3 -# 858| r858_1(glval) = VariableAddress[rb] : -# 858| r858_2(glval) = VariableAddress[d] : -# 858| r858_3(glval) = CheckedConvertOrThrow : r858_2 -# 858| r858_4(PolymorphicBase &) = CopyValue : r858_3 -# 858| m858_5(PolymorphicBase &) = Store : &:r858_1, r858_4 -# 860| r860_1(glval) = VariableAddress[pb] : -# 860| r860_2(PolymorphicBase *) = Load : &:r860_1, m857_5 -# 860| r860_3(PolymorphicDerived *) = CheckedConvertOrNull : r860_2 -# 860| r860_4(glval) = VariableAddress[pd] : -# 860| m860_5(PolymorphicDerived *) = Store : &:r860_4, r860_3 -# 861| r861_1(glval) = VariableAddress[rd] : -# 861| r861_2(glval) = VariableAddress[b] : -# 861| r861_3(glval) = CheckedConvertOrThrow : r861_2 -# 861| r861_4(PolymorphicDerived &) = CopyValue : r861_3 -# 861| m861_5(PolymorphicDerived &) = Store : &:r861_1, r861_4 -# 863| r863_1(glval) = VariableAddress[pv] : -# 863| r863_2(glval) = VariableAddress[pb] : -# 863| r863_3(PolymorphicBase *) = Load : &:r863_2, m857_5 -# 863| r863_4(void *) = DynamicCastToVoid : r863_3 -# 863| m863_5(void *) = Store : &:r863_1, r863_4 -# 864| r864_1(glval) = VariableAddress[pcv] : -# 864| r864_2(glval) = VariableAddress[pd] : -# 864| r864_3(PolymorphicDerived *) = Load : &:r864_2, m860_5 -# 864| r864_4(void *) = DynamicCastToVoid : r864_3 -# 864| m864_5(void *) = Store : &:r864_1, r864_4 -# 865| v865_1(void) = NoOp : -# 849| v849_4(void) = ReturnVoid : -# 849| v849_5(void) = UnmodeledUse : mu* -# 849| v849_6(void) = AliasedUse : ~m851_6 -# 849| v849_7(void) = ExitFunction : - -# 867| void String::String() -# 867| Block 0 -# 867| v867_1(void) = EnterFunction : -# 867| m867_2(unknown) = AliasedDefinition : -# 867| mu867_3(unknown) = UnmodeledDefinition : -# 867| r867_4(glval) = InitializeThis : -# 868| r868_1(glval) = FunctionAddress[String] : -# 868| r868_2(glval) = StringConstant[""] : -# 868| r868_3(char *) = Convert : r868_2 -# 868| v868_4(void) = Call : func:r868_1, this:r867_4, 0:r868_3 -# 868| m868_5(unknown) = ^CallSideEffect : ~m867_2 -# 868| m868_6(unknown) = Chi : total:m867_2, partial:m868_5 -# 868| m868_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r867_4 -# 868| m868_8(unknown) = Chi : total:m868_6, partial:m868_7 -# 868| v868_9(void) = ^BufferReadSideEffect[0] : &:r868_3, ~m867_2 -# 868| m868_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r868_3 -# 868| m868_11(unknown) = Chi : total:m868_8, partial:m868_10 -# 869| v869_1(void) = NoOp : -# 867| v867_5(void) = ReturnVoid : -# 867| v867_6(void) = UnmodeledUse : mu* -# 867| v867_7(void) = AliasedUse : ~m868_11 -# 867| v867_8(void) = ExitFunction : - -# 871| void ArrayConversions() -# 871| Block 0 -# 871| v871_1(void) = EnterFunction : -# 871| m871_2(unknown) = AliasedDefinition : -# 871| mu871_3(unknown) = UnmodeledDefinition : -# 872| r872_1(glval) = VariableAddress[a] : -# 872| m872_2(char[5]) = Uninitialized[a] : &:r872_1 -# 873| r873_1(glval) = VariableAddress[p] : -# 873| r873_2(glval) = VariableAddress[a] : -# 873| r873_3(char *) = Convert : r873_2 -# 873| r873_4(char *) = Convert : r873_3 -# 873| m873_5(char *) = Store : &:r873_1, r873_4 -# 874| r874_1(glval) = StringConstant["test"] : -# 874| r874_2(char *) = Convert : r874_1 -# 874| r874_3(glval) = VariableAddress[p] : -# 874| m874_4(char *) = Store : &:r874_3, r874_2 -# 875| r875_1(glval) = VariableAddress[a] : -# 875| r875_2(char *) = Convert : r875_1 -# 875| r875_3(int) = Constant[0] : -# 875| r875_4(glval) = PointerAdd[1] : r875_2, r875_3 -# 875| r875_5(char *) = CopyValue : r875_4 -# 875| r875_6(char *) = Convert : r875_5 -# 875| r875_7(glval) = VariableAddress[p] : -# 875| m875_8(char *) = Store : &:r875_7, r875_6 -# 876| r876_1(glval) = StringConstant["test"] : -# 876| r876_2(char *) = Convert : r876_1 -# 876| r876_3(int) = Constant[0] : -# 876| r876_4(glval) = PointerAdd[1] : r876_2, r876_3 -# 876| r876_5(char *) = CopyValue : r876_4 -# 876| r876_6(glval) = VariableAddress[p] : -# 876| m876_7(char *) = Store : &:r876_6, r876_5 -# 877| r877_1(glval) = VariableAddress[ra] : -# 877| r877_2(glval) = VariableAddress[a] : -# 877| r877_3(char(&)[5]) = CopyValue : r877_2 -# 877| m877_4(char(&)[5]) = Store : &:r877_1, r877_3 -# 878| r878_1(glval) = VariableAddress[rs] : -# 878| r878_2(glval) = StringConstant["test"] : -# 878| r878_3(char(&)[5]) = CopyValue : r878_2 -# 878| m878_4(char(&)[5]) = Store : &:r878_1, r878_3 -# 879| r879_1(glval) = VariableAddress[pa] : -# 879| r879_2(glval) = VariableAddress[a] : -# 879| r879_3(char(*)[5]) = CopyValue : r879_2 -# 879| r879_4(char(*)[5]) = Convert : r879_3 -# 879| m879_5(char(*)[5]) = Store : &:r879_1, r879_4 -# 880| r880_1(glval) = StringConstant["test"] : -# 880| r880_2(char(*)[5]) = CopyValue : r880_1 -# 880| r880_3(glval) = VariableAddress[pa] : -# 880| m880_4(char(*)[5]) = Store : &:r880_3, r880_2 -# 881| v881_1(void) = NoOp : -# 871| v871_4(void) = ReturnVoid : -# 871| v871_5(void) = UnmodeledUse : mu* -# 871| v871_6(void) = AliasedUse : ~m871_2 -# 871| v871_7(void) = ExitFunction : - -# 883| void FuncPtrConversions(int(*)(int), void*) -# 883| Block 0 -# 883| v883_1(void) = EnterFunction : -# 883| m883_2(unknown) = AliasedDefinition : -# 883| mu883_3(unknown) = UnmodeledDefinition : -# 883| r883_4(glval<..(*)(..)>) = VariableAddress[pfn] : -# 883| m883_5(..(*)(..)) = InitializeParameter[pfn] : &:r883_4 -# 883| r883_6(glval) = VariableAddress[p] : -# 883| m883_7(void *) = InitializeParameter[p] : &:r883_6 -# 883| r883_8(void *) = Load : &:r883_6, m883_7 -# 883| m883_9(unknown) = InitializeIndirection[p] : &:r883_8 -# 883| m883_10(unknown) = Chi : total:m883_2, partial:m883_9 -# 884| r884_1(glval<..(*)(..)>) = VariableAddress[pfn] : -# 884| r884_2(..(*)(..)) = Load : &:r884_1, m883_5 -# 884| r884_3(void *) = Convert : r884_2 -# 884| r884_4(glval) = VariableAddress[p] : -# 884| m884_5(void *) = Store : &:r884_4, r884_3 -# 885| r885_1(glval) = VariableAddress[p] : -# 885| r885_2(void *) = Load : &:r885_1, m884_5 -# 885| r885_3(..(*)(..)) = Convert : r885_2 -# 885| r885_4(glval<..(*)(..)>) = VariableAddress[pfn] : -# 885| m885_5(..(*)(..)) = Store : &:r885_4, r885_3 -# 886| v886_1(void) = NoOp : -# 883| v883_11(void) = ReturnIndirection : &:r883_8, ~m883_10 -# 883| v883_12(void) = ReturnVoid : -# 883| v883_13(void) = UnmodeledUse : mu* -# 883| v883_14(void) = AliasedUse : ~m883_10 -# 883| v883_15(void) = ExitFunction : - -# 888| void VarArgUsage(int) -# 888| Block 0 -# 888| v888_1(void) = EnterFunction : -# 888| m888_2(unknown) = AliasedDefinition : -# 888| mu888_3(unknown) = UnmodeledDefinition : -# 888| r888_4(glval) = VariableAddress[x] : -# 888| m888_5(int) = InitializeParameter[x] : &:r888_4 -# 889| r889_1(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 889| m889_2(__va_list_tag[1]) = Uninitialized[args] : &:r889_1 -# 891| r891_1(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 891| r891_2(__va_list_tag *) = Convert : r891_1 -# 891| r891_3(glval) = VariableAddress[x] : -# 891| v891_4(void) = VarArgsStart : 0:r891_2, 1:r891_3 -# 892| r892_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 892| m892_2(__va_list_tag[1]) = Uninitialized[args2] : &:r892_1 -# 893| r893_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 893| r893_2(__va_list_tag *) = Convert : r893_1 -# 893| r893_3(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 893| r893_4(__va_list_tag *) = Convert : r893_3 -# 893| v893_5(void) = VarArgsStart : 0:r893_2, 1:r893_4 -# 894| r894_1(glval) = VariableAddress[d] : -# 894| r894_2(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 894| r894_3(__va_list_tag *) = Convert : r894_2 -# 894| r894_4(glval) = VarArg : 0:r894_3 -# 894| r894_5(double) = Load : &:r894_4, ~m888_2 -# 894| m894_6(double) = Store : &:r894_1, r894_5 -# 895| r895_1(glval) = VariableAddress[f] : -# 895| r895_2(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 895| r895_3(__va_list_tag *) = Convert : r895_2 -# 895| r895_4(glval) = VarArg : 0:r895_3 -# 895| r895_5(double) = Load : &:r895_4, ~m888_2 -# 895| r895_6(float) = Convert : r895_5 -# 895| m895_7(float) = Store : &:r895_1, r895_6 -# 896| r896_1(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 896| r896_2(__va_list_tag *) = Convert : r896_1 -# 896| v896_3(void) = VarArgsEnd : 0:r896_2 -# 897| r897_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 897| r897_2(__va_list_tag *) = Convert : r897_1 -# 897| v897_3(void) = VarArgsEnd : 0:r897_2 -# 898| v898_1(void) = NoOp : -# 888| v888_6(void) = ReturnVoid : -# 888| v888_7(void) = UnmodeledUse : mu* -# 888| v888_8(void) = AliasedUse : ~m888_2 -# 888| v888_9(void) = ExitFunction : - -# 900| void CastToVoid(int) -# 900| Block 0 -# 900| v900_1(void) = EnterFunction : -# 900| m900_2(unknown) = AliasedDefinition : -# 900| mu900_3(unknown) = UnmodeledDefinition : -# 900| r900_4(glval) = VariableAddress[x] : -# 900| m900_5(int) = InitializeParameter[x] : &:r900_4 -# 901| r901_1(glval) = VariableAddress[x] : -# 901| v901_2(void) = Convert : r901_1 -# 902| v902_1(void) = NoOp : -# 900| v900_6(void) = ReturnVoid : -# 900| v900_7(void) = UnmodeledUse : mu* -# 900| v900_8(void) = AliasedUse : ~m900_2 -# 900| v900_9(void) = ExitFunction : - -# 904| void ConstantConditions(int) -# 904| Block 0 -# 904| v904_1(void) = EnterFunction : -# 904| m904_2(unknown) = AliasedDefinition : -# 904| mu904_3(unknown) = UnmodeledDefinition : -# 904| r904_4(glval) = VariableAddress[x] : -# 904| m904_5(int) = InitializeParameter[x] : &:r904_4 -# 905| r905_1(glval) = VariableAddress[a] : -# 905| r905_2(bool) = Constant[1] : -# 905| m905_3(bool) = Store : &:r905_1, r905_2 -# 906| r906_1(glval) = VariableAddress[b] : -# 906| r906_2(bool) = Constant[1] : -# 906| v906_3(void) = ConditionalBranch : r906_2 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 906| Block 1 -# 906| r906_4(glval) = VariableAddress[x] : -# 906| r906_5(int) = Load : &:r906_4, m904_5 -# 906| r906_6(glval) = VariableAddress[#temp906:11] : -# 906| m906_7(int) = Store : &:r906_6, r906_5 -# 906| r906_8(glval) = VariableAddress[#temp906:11] : -# 906| r906_9(int) = Load : &:r906_8, m906_7 -# 906| m906_10(int) = Store : &:r906_1, r906_9 -# 907| v907_1(void) = NoOp : -# 904| v904_6(void) = ReturnVoid : -# 904| v904_7(void) = UnmodeledUse : mu* -# 904| v904_8(void) = AliasedUse : ~m904_2 -# 904| v904_9(void) = ExitFunction : - -# 904| Block 2 -# 904| v904_10(void) = Unreached : - -# 940| void OperatorNew() -# 940| Block 0 -# 940| v940_1(void) = EnterFunction : -# 940| m940_2(unknown) = AliasedDefinition : -# 940| mu940_3(unknown) = UnmodeledDefinition : -# 941| r941_1(glval) = FunctionAddress[operator new] : -# 941| r941_2(unsigned long) = Constant[4] : -# 941| r941_3(void *) = Call : func:r941_1, 0:r941_2 -# 941| m941_4(unknown) = ^CallSideEffect : ~m940_2 -# 941| m941_5(unknown) = Chi : total:m940_2, partial:m941_4 -# 941| r941_6(int *) = Convert : r941_3 -# 942| r942_1(glval) = FunctionAddress[operator new] : -# 942| r942_2(unsigned long) = Constant[4] : -# 942| r942_3(float) = Constant[1.0] : -# 942| r942_4(void *) = Call : func:r942_1, 0:r942_2, 1:r942_3 -# 942| m942_5(unknown) = ^CallSideEffect : ~m941_5 -# 942| m942_6(unknown) = Chi : total:m941_5, partial:m942_5 -# 942| r942_7(int *) = Convert : r942_4 -# 943| r943_1(glval) = FunctionAddress[operator new] : -# 943| r943_2(unsigned long) = Constant[4] : -# 943| r943_3(void *) = Call : func:r943_1, 0:r943_2 -# 943| m943_4(unknown) = ^CallSideEffect : ~m942_6 -# 943| m943_5(unknown) = Chi : total:m942_6, partial:m943_4 -# 943| r943_6(int *) = Convert : r943_3 -# 943| r943_7(int) = Constant[0] : -# 943| m943_8(int) = Store : &:r943_6, r943_7 -# 943| m943_9(unknown) = Chi : total:m943_5, partial:m943_8 -# 944| r944_1(glval) = FunctionAddress[operator new] : -# 944| r944_2(unsigned long) = Constant[8] : -# 944| r944_3(void *) = Call : func:r944_1, 0:r944_2 -# 944| m944_4(unknown) = ^CallSideEffect : ~m943_9 -# 944| m944_5(unknown) = Chi : total:m943_9, partial:m944_4 -# 944| r944_6(String *) = Convert : r944_3 -# 944| r944_7(glval) = FunctionAddress[String] : -# 944| v944_8(void) = Call : func:r944_7, this:r944_6 -# 944| m944_9(unknown) = ^CallSideEffect : ~m944_5 -# 944| m944_10(unknown) = Chi : total:m944_5, partial:m944_9 -# 944| m944_11(String) = ^IndirectMayWriteSideEffect[-1] : &:r944_6 -# 944| m944_12(unknown) = Chi : total:m944_10, partial:m944_11 -# 945| r945_1(glval) = FunctionAddress[operator new] : -# 945| r945_2(unsigned long) = Constant[8] : -# 945| r945_3(float) = Constant[1.0] : -# 945| r945_4(void *) = Call : func:r945_1, 0:r945_2, 1:r945_3 -# 945| m945_5(unknown) = ^CallSideEffect : ~m944_12 -# 945| m945_6(unknown) = Chi : total:m944_12, partial:m945_5 -# 945| r945_7(String *) = Convert : r945_4 -# 945| r945_8(glval) = FunctionAddress[String] : -# 945| r945_9(glval) = StringConstant["hello"] : -# 945| r945_10(char *) = Convert : r945_9 -# 945| v945_11(void) = Call : func:r945_8, this:r945_7, 0:r945_10 -# 945| m945_12(unknown) = ^CallSideEffect : ~m945_6 -# 945| m945_13(unknown) = Chi : total:m945_6, partial:m945_12 -# 945| m945_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r945_7 -# 945| m945_15(unknown) = Chi : total:m945_13, partial:m945_14 -# 945| v945_16(void) = ^BufferReadSideEffect[0] : &:r945_10, ~m940_2 -# 945| m945_17(unknown) = ^BufferMayWriteSideEffect[0] : &:r945_10 -# 945| m945_18(unknown) = Chi : total:m945_15, partial:m945_17 -# 946| r946_1(glval) = FunctionAddress[operator new] : -# 946| r946_2(unsigned long) = Constant[256] : -# 946| r946_3(align_val_t) = Constant[128] : -# 946| r946_4(void *) = Call : func:r946_1, 0:r946_2, 1:r946_3 -# 946| m946_5(unknown) = ^CallSideEffect : ~m945_18 -# 946| m946_6(unknown) = Chi : total:m945_18, partial:m946_5 -# 946| r946_7(Overaligned *) = Convert : r946_4 -# 947| r947_1(glval) = FunctionAddress[operator new] : -# 947| r947_2(unsigned long) = Constant[256] : -# 947| r947_3(align_val_t) = Constant[128] : -# 947| r947_4(float) = Constant[1.0] : -# 947| r947_5(void *) = Call : func:r947_1, 0:r947_2, 1:r947_3, 2:r947_4 -# 947| m947_6(unknown) = ^CallSideEffect : ~m946_6 -# 947| m947_7(unknown) = Chi : total:m946_6, partial:m947_6 -# 947| r947_8(Overaligned *) = Convert : r947_5 -# 947| r947_9(Overaligned) = Constant[0] : -# 947| m947_10(Overaligned) = Store : &:r947_8, r947_9 -# 947| m947_11(unknown) = Chi : total:m947_7, partial:m947_10 -# 948| v948_1(void) = NoOp : -# 940| v940_4(void) = ReturnVoid : -# 940| v940_5(void) = UnmodeledUse : mu* -# 940| v940_6(void) = AliasedUse : ~m947_11 -# 940| v940_7(void) = ExitFunction : - -# 950| void OperatorNewArray(int) -# 950| Block 0 -# 950| v950_1(void) = EnterFunction : -# 950| m950_2(unknown) = AliasedDefinition : -# 950| mu950_3(unknown) = UnmodeledDefinition : -# 950| r950_4(glval) = VariableAddress[n] : -# 950| m950_5(int) = InitializeParameter[n] : &:r950_4 -# 951| r951_1(glval) = FunctionAddress[operator new[]] : -# 951| r951_2(unsigned long) = Constant[40] : -# 951| r951_3(void *) = Call : func:r951_1, 0:r951_2 -# 951| m951_4(unknown) = ^CallSideEffect : ~m950_2 -# 951| m951_5(unknown) = Chi : total:m950_2, partial:m951_4 -# 951| r951_6(int *) = Convert : r951_3 -# 952| r952_1(glval) = FunctionAddress[operator new[]] : -# 952| r952_2(glval) = VariableAddress[n] : -# 952| r952_3(int) = Load : &:r952_2, m950_5 -# 952| r952_4(unsigned long) = Convert : r952_3 -# 952| r952_5(unsigned long) = Constant[4] : -# 952| r952_6(unsigned long) = Mul : r952_4, r952_5 -# 952| r952_7(void *) = Call : func:r952_1, 0:r952_6 -# 952| m952_8(unknown) = ^CallSideEffect : ~m951_5 -# 952| m952_9(unknown) = Chi : total:m951_5, partial:m952_8 -# 952| r952_10(int *) = Convert : r952_7 -# 953| r953_1(glval) = FunctionAddress[operator new[]] : -# 953| r953_2(glval) = VariableAddress[n] : -# 953| r953_3(int) = Load : &:r953_2, m950_5 -# 953| r953_4(unsigned long) = Convert : r953_3 -# 953| r953_5(unsigned long) = Constant[4] : -# 953| r953_6(unsigned long) = Mul : r953_4, r953_5 -# 953| r953_7(float) = Constant[1.0] : -# 953| r953_8(void *) = Call : func:r953_1, 0:r953_6, 1:r953_7 -# 953| m953_9(unknown) = ^CallSideEffect : ~m952_9 -# 953| m953_10(unknown) = Chi : total:m952_9, partial:m953_9 -# 953| r953_11(int *) = Convert : r953_8 -# 954| r954_1(glval) = FunctionAddress[operator new[]] : -# 954| r954_2(glval) = VariableAddress[n] : -# 954| r954_3(int) = Load : &:r954_2, m950_5 -# 954| r954_4(unsigned long) = Convert : r954_3 -# 954| r954_5(unsigned long) = Constant[8] : -# 954| r954_6(unsigned long) = Mul : r954_4, r954_5 -# 954| r954_7(void *) = Call : func:r954_1, 0:r954_6 -# 954| m954_8(unknown) = ^CallSideEffect : ~m953_10 -# 954| m954_9(unknown) = Chi : total:m953_10, partial:m954_8 -# 954| r954_10(String *) = Convert : r954_7 -# 955| r955_1(glval) = FunctionAddress[operator new[]] : -# 955| r955_2(glval) = VariableAddress[n] : -# 955| r955_3(int) = Load : &:r955_2, m950_5 -# 955| r955_4(unsigned long) = Convert : r955_3 -# 955| r955_5(unsigned long) = Constant[256] : -# 955| r955_6(unsigned long) = Mul : r955_4, r955_5 -# 955| r955_7(align_val_t) = Constant[128] : -# 955| r955_8(void *) = Call : func:r955_1, 0:r955_6, 1:r955_7 -# 955| m955_9(unknown) = ^CallSideEffect : ~m954_9 -# 955| m955_10(unknown) = Chi : total:m954_9, partial:m955_9 -# 955| r955_11(Overaligned *) = Convert : r955_8 -# 956| r956_1(glval) = FunctionAddress[operator new[]] : -# 956| r956_2(unsigned long) = Constant[2560] : -# 956| r956_3(align_val_t) = Constant[128] : -# 956| r956_4(float) = Constant[1.0] : -# 956| r956_5(void *) = Call : func:r956_1, 0:r956_2, 1:r956_3, 2:r956_4 -# 956| m956_6(unknown) = ^CallSideEffect : ~m955_10 -# 956| m956_7(unknown) = Chi : total:m955_10, partial:m956_6 -# 956| r956_8(Overaligned *) = Convert : r956_5 -# 957| r957_1(glval) = FunctionAddress[operator new[]] : -# 957| r957_2(glval) = VariableAddress[n] : -# 957| r957_3(int) = Load : &:r957_2, m950_5 -# 957| r957_4(unsigned long) = Convert : r957_3 -# 957| r957_5(unsigned long) = Constant[1] : -# 957| r957_6(unsigned long) = Mul : r957_4, r957_5 -# 957| r957_7(void *) = Call : func:r957_1, 0:r957_6 -# 957| m957_8(unknown) = ^CallSideEffect : ~m956_7 -# 957| m957_9(unknown) = Chi : total:m956_7, partial:m957_8 -# 957| r957_10(DefaultCtorWithDefaultParam *) = Convert : r957_7 -# 958| r958_1(glval) = FunctionAddress[operator new[]] : -# 958| r958_2(glval) = VariableAddress[n] : -# 958| r958_3(int) = Load : &:r958_2, m950_5 -# 958| r958_4(unsigned long) = Convert : r958_3 -# 958| r958_5(unsigned long) = Constant[4] : -# 958| r958_6(unsigned long) = Mul : r958_4, r958_5 -# 958| r958_7(void *) = Call : func:r958_1, 0:r958_6 -# 958| m958_8(unknown) = ^CallSideEffect : ~m957_9 -# 958| m958_9(unknown) = Chi : total:m957_9, partial:m958_8 -# 958| r958_10(int *) = Convert : r958_7 -# 959| v959_1(void) = NoOp : -# 950| v950_6(void) = ReturnVoid : -# 950| v950_7(void) = UnmodeledUse : mu* -# 950| v950_8(void) = AliasedUse : ~m958_9 -# 950| v950_9(void) = ExitFunction : - -# 961| int designatedInit() -# 961| Block 0 -# 961| v961_1(void) = EnterFunction : -# 961| m961_2(unknown) = AliasedDefinition : -# 961| mu961_3(unknown) = UnmodeledDefinition : -# 962| r962_1(glval) = VariableAddress[a1] : -# 962| m962_2(int[1000]) = Uninitialized[a1] : &:r962_1 -# 962| r962_3(int) = Constant[0] : -# 962| r962_4(glval) = PointerAdd[4] : r962_1, r962_3 -# 962| r962_5(unknown[8]) = Constant[0] : -# 962| m962_6(unknown[8]) = Store : &:r962_4, r962_5 -# 962| m962_7(int[1000]) = Chi : total:m962_2, partial:m962_6 -# 962| r962_8(int) = Constant[2] : -# 962| r962_9(glval) = PointerAdd[4] : r962_1, r962_8 -# 962| r962_10(int) = Constant[10002] : -# 962| m962_11(int) = Store : &:r962_9, r962_10 -# 962| m962_12(int[1000]) = Chi : total:m962_7, partial:m962_11 -# 962| r962_13(int) = Constant[3] : -# 962| r962_14(glval) = PointerAdd[4] : r962_1, r962_13 -# 962| r962_15(unknown[3588]) = Constant[0] : -# 962| m962_16(unknown[3588]) = Store : &:r962_14, r962_15 -# 962| m962_17(int[1000]) = Chi : total:m962_12, partial:m962_16 -# 962| r962_18(int) = Constant[900] : -# 962| r962_19(glval) = PointerAdd[4] : r962_1, r962_18 -# 962| r962_20(int) = Constant[10900] : -# 962| m962_21(int) = Store : &:r962_19, r962_20 -# 962| m962_22(int[1000]) = Chi : total:m962_17, partial:m962_21 -# 962| r962_23(int) = Constant[901] : -# 962| r962_24(glval) = PointerAdd[4] : r962_1, r962_23 -# 962| r962_25(unknown[396]) = Constant[0] : -# 962| m962_26(unknown[396]) = Store : &:r962_24, r962_25 -# 962| m962_27(int[1000]) = Chi : total:m962_22, partial:m962_26 -# 963| r963_1(glval) = VariableAddress[#return] : -# 963| r963_2(glval) = VariableAddress[a1] : -# 963| r963_3(int *) = Convert : r963_2 -# 963| r963_4(int) = Constant[900] : -# 963| r963_5(glval) = PointerAdd[4] : r963_3, r963_4 -# 963| r963_6(int) = Load : &:r963_5, m962_21 -# 963| m963_7(int) = Store : &:r963_1, r963_6 -# 961| r961_4(glval) = VariableAddress[#return] : -# 961| v961_5(void) = ReturnValue : &:r961_4, m963_7 -# 961| v961_6(void) = UnmodeledUse : mu* -# 961| v961_7(void) = AliasedUse : ~m961_2 -# 961| v961_8(void) = ExitFunction : - -# 966| void IfStmtWithDeclaration(int, int) -# 966| Block 0 -# 966| v966_1(void) = EnterFunction : -# 966| m966_2(unknown) = AliasedDefinition : -# 966| mu966_3(unknown) = UnmodeledDefinition : -# 966| r966_4(glval) = VariableAddress[x] : -# 966| m966_5(int) = InitializeParameter[x] : &:r966_4 -# 966| r966_6(glval) = VariableAddress[y] : -# 966| m966_7(int) = InitializeParameter[y] : &:r966_6 -# 967| r967_1(glval) = VariableAddress[b] : -# 967| r967_2(glval) = VariableAddress[x] : -# 967| r967_3(int) = Load : &:r967_2, m966_5 -# 967| r967_4(glval) = VariableAddress[y] : -# 967| r967_5(int) = Load : &:r967_4, m966_7 -# 967| r967_6(bool) = CompareLT : r967_3, r967_5 -# 967| m967_7(bool) = Store : &:r967_1, r967_6 -# 967| r967_8(glval) = VariableAddress[b] : -# 967| r967_9(bool) = Load : &:r967_8, m967_7 -# 967| r967_10(bool) = CopyValue : r967_9 -# 967| v967_11(void) = ConditionalBranch : r967_10 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 968| Block 1 -# 968| r968_1(int) = Constant[5] : -# 968| r968_2(glval) = VariableAddress[x] : -# 968| m968_3(int) = Store : &:r968_2, r968_1 -#-----| Goto -> Block 6 - -# 970| Block 2 -# 970| r970_1(glval) = VariableAddress[z] : -# 970| r970_2(glval) = VariableAddress[x] : -# 970| r970_3(int) = Load : &:r970_2, m966_5 -# 970| r970_4(glval) = VariableAddress[y] : -# 970| r970_5(int) = Load : &:r970_4, m966_7 -# 970| r970_6(int) = Add : r970_3, r970_5 -# 970| m970_7(int) = Store : &:r970_1, r970_6 -# 970| r970_8(glval) = VariableAddress[z] : -# 970| r970_9(int) = Load : &:r970_8, m970_7 -# 970| r970_10(int) = Constant[0] : -# 970| r970_11(bool) = CompareNE : r970_9, r970_10 -# 970| r970_12(bool) = CopyValue : r970_11 -# 970| v970_13(void) = ConditionalBranch : r970_12 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 971| Block 3 -# 971| r971_1(int) = Constant[7] : -# 971| r971_2(glval) = VariableAddress[y] : -# 971| m971_3(int) = Store : &:r971_2, r971_1 -#-----| Goto -> Block 6 - -# 973| Block 4 -# 973| r973_1(glval) = VariableAddress[p] : -# 973| r973_2(glval) = VariableAddress[x] : -# 973| r973_3(int *) = CopyValue : r973_2 -# 973| m973_4(int *) = Store : &:r973_1, r973_3 -# 973| r973_5(glval) = VariableAddress[p] : -# 973| r973_6(int *) = Load : &:r973_5, m973_4 -# 973| r973_7(int *) = Constant[0] : -# 973| r973_8(bool) = CompareNE : r973_6, r973_7 -# 973| r973_9(bool) = CopyValue : r973_8 -# 973| v973_10(void) = ConditionalBranch : r973_9 -#-----| False -> Block 6 -#-----| True -> Block 5 - -# 974| Block 5 -# 974| r974_1(int) = Constant[2] : -# 974| r974_2(glval) = VariableAddress[p] : -# 974| r974_3(int *) = Load : &:r974_2, m973_4 -# 974| r974_4(glval) = CopyValue : r974_3 -# 974| m974_5(int) = Store : &:r974_4, r974_1 -#-----| Goto -> Block 6 - -# 976| Block 6 -# 976| v976_1(void) = NoOp : -# 966| v966_8(void) = ReturnVoid : -# 966| v966_9(void) = UnmodeledUse : mu* -# 966| v966_10(void) = AliasedUse : ~m966_2 -# 966| v966_11(void) = ExitFunction : - -# 978| void WhileStmtWithDeclaration(int, int) -# 978| Block 0 -# 978| v978_1(void) = EnterFunction : -# 978| m978_2(unknown) = AliasedDefinition : -# 978| mu978_3(unknown) = UnmodeledDefinition : -# 978| r978_4(glval) = VariableAddress[x] : -# 978| m978_5(int) = InitializeParameter[x] : &:r978_4 -# 978| r978_6(glval) = VariableAddress[y] : -# 978| m978_7(int) = InitializeParameter[y] : &:r978_6 -#-----| Goto -> Block 7 - -# 979| Block 1 -# 979| v979_1(void) = NoOp : -#-----| Goto (back edge) -> Block 7 - -# 981| Block 2 -# 981| r981_1(glval) = VariableAddress[z] : -# 981| r981_2(glval) = VariableAddress[x] : -# 981| r981_3(int) = Load : &:r981_2, m978_5 -# 981| r981_4(glval) = VariableAddress[y] : -# 981| r981_5(int) = Load : &:r981_4, m978_7 -# 981| r981_6(int) = Add : r981_3, r981_5 -# 981| m981_7(int) = Store : &:r981_1, r981_6 -# 981| r981_8(glval) = VariableAddress[z] : -# 981| r981_9(int) = Load : &:r981_8, m981_7 -# 981| r981_10(int) = Constant[0] : -# 981| r981_11(bool) = CompareNE : r981_9, r981_10 -# 981| r981_12(bool) = CopyValue : r981_11 -# 981| v981_13(void) = ConditionalBranch : r981_12 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 981| Block 3 -# 981| v981_14(void) = NoOp : -#-----| Goto (back edge) -> Block 2 - -# 983| Block 4 -# 983| r983_1(glval) = VariableAddress[p] : -# 983| r983_2(glval) = VariableAddress[x] : -# 983| r983_3(int *) = CopyValue : r983_2 -# 983| m983_4(int *) = Store : &:r983_1, r983_3 -# 983| r983_5(glval) = VariableAddress[p] : -# 983| r983_6(int *) = Load : &:r983_5, m983_4 -# 983| r983_7(int *) = Constant[0] : -# 983| r983_8(bool) = CompareNE : r983_6, r983_7 -# 983| r983_9(bool) = CopyValue : r983_8 -# 983| v983_10(void) = ConditionalBranch : r983_9 -#-----| False -> Block 6 -#-----| True -> Block 5 - -# 983| Block 5 -# 983| v983_11(void) = NoOp : -#-----| Goto (back edge) -> Block 4 - -# 985| Block 6 -# 985| v985_1(void) = NoOp : -# 978| v978_8(void) = ReturnVoid : -# 978| v978_9(void) = UnmodeledUse : mu* -# 978| v978_10(void) = AliasedUse : ~m978_2 -# 978| v978_11(void) = ExitFunction : - -# 979| Block 7 -# 979| r979_2(glval) = VariableAddress[b] : -# 979| r979_3(glval) = VariableAddress[x] : -# 979| r979_4(int) = Load : &:r979_3, m978_5 -# 979| r979_5(glval) = VariableAddress[y] : -# 979| r979_6(int) = Load : &:r979_5, m978_7 -# 979| r979_7(bool) = CompareLT : r979_4, r979_6 -# 979| m979_8(bool) = Store : &:r979_2, r979_7 -# 979| r979_9(glval) = VariableAddress[b] : -# 979| r979_10(bool) = Load : &:r979_9, m979_8 -# 979| r979_11(bool) = CopyValue : r979_10 -# 979| v979_12(void) = ConditionalBranch : r979_11 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 987| int PointerDecay(int[], int(float)) -# 987| Block 0 -# 987| v987_1(void) = EnterFunction : -# 987| m987_2(unknown) = AliasedDefinition : -# 987| mu987_3(unknown) = UnmodeledDefinition : -# 987| r987_4(glval) = VariableAddress[a] : -# 987| m987_5(int *) = InitializeParameter[a] : &:r987_4 -# 987| r987_6(int *) = Load : &:r987_4, m987_5 -# 987| m987_7(unknown) = InitializeIndirection[a] : &:r987_6 -# 987| m987_8(unknown) = Chi : total:m987_2, partial:m987_7 -# 987| r987_9(glval<..(*)(..)>) = VariableAddress[fn] : -# 987| m987_10(..(*)(..)) = InitializeParameter[fn] : &:r987_9 -# 988| r988_1(glval) = VariableAddress[#return] : -# 988| r988_2(glval) = VariableAddress[a] : -# 988| r988_3(int *) = Load : &:r988_2, m987_5 -# 988| r988_4(int) = Constant[0] : -# 988| r988_5(glval) = PointerAdd[4] : r988_3, r988_4 -# 988| r988_6(int) = Load : &:r988_5, ~m987_8 -# 988| r988_7(glval<..(*)(..)>) = VariableAddress[fn] : -# 988| r988_8(..(*)(..)) = Load : &:r988_7, m987_10 -# 988| r988_9(float) = Constant[1.0] : -# 988| r988_10(int) = Call : func:r988_8, 0:r988_9 -# 988| m988_11(unknown) = ^CallSideEffect : ~m987_8 -# 988| m988_12(unknown) = Chi : total:m987_8, partial:m988_11 -# 988| r988_13(int) = Add : r988_6, r988_10 -# 988| m988_14(int) = Store : &:r988_1, r988_13 -# 987| v987_11(void) = ReturnIndirection : &:r987_6, ~m988_12 -# 987| r987_12(glval) = VariableAddress[#return] : -# 987| v987_13(void) = ReturnValue : &:r987_12, m988_14 -# 987| v987_14(void) = UnmodeledUse : mu* -# 987| v987_15(void) = AliasedUse : ~m988_12 -# 987| v987_16(void) = ExitFunction : - -# 991| int ExprStmt(int, int, int) -# 991| Block 0 -# 991| v991_1(void) = EnterFunction : -# 991| m991_2(unknown) = AliasedDefinition : -# 991| mu991_3(unknown) = UnmodeledDefinition : -# 991| r991_4(glval) = VariableAddress[b] : -# 991| m991_5(int) = InitializeParameter[b] : &:r991_4 -# 991| r991_6(glval) = VariableAddress[y] : -# 991| m991_7(int) = InitializeParameter[y] : &:r991_6 -# 991| r991_8(glval) = VariableAddress[z] : -# 991| m991_9(int) = InitializeParameter[z] : &:r991_8 -# 992| r992_1(glval) = VariableAddress[x] : -# 993| r993_1(glval) = VariableAddress[w] : -# 993| m993_2(int) = Uninitialized[w] : &:r993_1 -# 994| r994_1(glval) = VariableAddress[b] : -# 994| r994_2(int) = Load : &:r994_1, m991_5 -# 994| r994_3(int) = Constant[0] : -# 994| r994_4(bool) = CompareNE : r994_2, r994_3 -# 994| v994_5(void) = ConditionalBranch : r994_4 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 995| Block 1 -# 995| r995_1(glval) = VariableAddress[y] : -# 995| r995_2(int) = Load : &:r995_1, m991_7 -# 995| r995_3(glval) = VariableAddress[w] : -# 995| m995_4(int) = Store : &:r995_3, r995_2 -#-----| Goto -> Block 3 - -# 997| Block 2 -# 997| r997_1(glval) = VariableAddress[z] : -# 997| r997_2(int) = Load : &:r997_1, m991_9 -# 997| r997_3(glval) = VariableAddress[w] : -# 997| m997_4(int) = Store : &:r997_3, r997_2 -#-----| Goto -> Block 3 - -# 999| Block 3 -# 999| m999_1(int) = Phi : from 1:m995_4, from 2:m997_4 -# 999| r999_2(glval) = VariableAddress[w] : -# 999| r999_3(int) = Load : &:r999_2, m999_1 -# 992| r992_2(int) = CopyValue : r999_3 -# 992| m992_3(int) = Store : &:r992_1, r992_2 -# 1002| r1002_1(glval) = VariableAddress[#return] : -# 1002| r1002_2(glval) = VariableAddress[x] : -# 1002| r1002_3(int) = Load : &:r1002_2, m992_3 -# 1002| r1002_4(int) = CopyValue : r1002_3 -# 1002| m1002_5(int) = Store : &:r1002_1, r1002_4 -# 991| r991_10(glval) = VariableAddress[#return] : -# 991| v991_11(void) = ReturnValue : &:r991_10, m1002_5 -# 991| v991_12(void) = UnmodeledUse : mu* -# 991| v991_13(void) = AliasedUse : ~m991_2 -# 991| v991_14(void) = ExitFunction : - -# 1006| void OperatorDelete() -# 1006| Block 0 -# 1006| v1006_1(void) = EnterFunction : -# 1006| m1006_2(unknown) = AliasedDefinition : -# 1006| mu1006_3(unknown) = UnmodeledDefinition : -# 1007| r1007_1(int *) = Constant[0] : -# 1007| v1007_2(void) = NoOp : -# 1008| r1008_1(String *) = Constant[0] : -# 1008| v1008_2(void) = NoOp : -# 1009| r1009_1(SizedDealloc *) = Constant[0] : -# 1009| v1009_2(void) = NoOp : -# 1010| r1010_1(Overaligned *) = Constant[0] : -# 1010| v1010_2(void) = NoOp : -# 1011| r1011_1(PolymorphicBase *) = Constant[0] : -# 1011| v1011_2(void) = NoOp : -# 1012| v1012_1(void) = NoOp : -# 1006| v1006_4(void) = ReturnVoid : -# 1006| v1006_5(void) = UnmodeledUse : mu* -# 1006| v1006_6(void) = AliasedUse : ~m1006_2 -# 1006| v1006_7(void) = ExitFunction : - -# 1015| void OperatorDeleteArray() -# 1015| Block 0 -# 1015| v1015_1(void) = EnterFunction : -# 1015| m1015_2(unknown) = AliasedDefinition : -# 1015| mu1015_3(unknown) = UnmodeledDefinition : -# 1016| r1016_1(int *) = Constant[0] : -# 1016| v1016_2(void) = NoOp : -# 1017| r1017_1(String *) = Constant[0] : -# 1017| v1017_2(void) = NoOp : -# 1018| r1018_1(SizedDealloc *) = Constant[0] : -# 1018| v1018_2(void) = NoOp : -# 1019| r1019_1(Overaligned *) = Constant[0] : -# 1019| v1019_2(void) = NoOp : -# 1020| r1020_1(PolymorphicBase *) = Constant[0] : -# 1020| v1020_2(void) = NoOp : -# 1021| v1021_1(void) = NoOp : -# 1015| v1015_4(void) = ReturnVoid : -# 1015| v1015_5(void) = UnmodeledUse : mu* -# 1015| v1015_6(void) = AliasedUse : ~m1015_2 -# 1015| v1015_7(void) = ExitFunction : - -# 1025| void EmptyStructInit() -# 1025| Block 0 -# 1025| v1025_1(void) = EnterFunction : -# 1025| m1025_2(unknown) = AliasedDefinition : -# 1025| mu1025_3(unknown) = UnmodeledDefinition : -# 1026| r1026_1(glval) = VariableAddress[s] : -# 1026| m1026_2(EmptyStruct) = Uninitialized[s] : &:r1026_1 -# 1027| v1027_1(void) = NoOp : -# 1025| v1025_4(void) = ReturnVoid : -# 1025| v1025_5(void) = UnmodeledUse : mu* -# 1025| v1025_6(void) = AliasedUse : ~m1025_2 -# 1025| v1025_7(void) = ExitFunction : - -# 1029| void (lambda [] type at line 1029, col. 12)::operator()() const -# 1029| Block 0 -# 1029| v1029_1(void) = EnterFunction : -# 1029| m1029_2(unknown) = AliasedDefinition : -# 1029| mu1029_3(unknown) = UnmodeledDefinition : -# 1029| r1029_4(glval) = InitializeThis : -# 1029| v1029_5(void) = NoOp : -# 1029| v1029_6(void) = ReturnVoid : -# 1029| v1029_7(void) = UnmodeledUse : mu* -# 1029| v1029_8(void) = AliasedUse : ~m1029_2 -# 1029| v1029_9(void) = ExitFunction : - -# 1029| void(* (lambda [] type at line 1029, col. 12)::operator void (*)()() const)() -# 1029| Block 0 -# 1029| v1029_1(void) = EnterFunction : -# 1029| m1029_2(unknown) = AliasedDefinition : -# 1029| mu1029_3(unknown) = UnmodeledDefinition : -# 1029| r1029_4(glval) = InitializeThis : -# 1029| r1029_5(glval<..(*)(..)>) = VariableAddress[#return] : -# 1029| r1029_6(..(*)(..)) = FunctionAddress[_FUN] : -# 1029| m1029_7(..(*)(..)) = Store : &:r1029_5, r1029_6 -# 1029| r1029_8(glval<..(*)(..)>) = VariableAddress[#return] : -# 1029| v1029_9(void) = ReturnValue : &:r1029_8, m1029_7 -# 1029| v1029_10(void) = UnmodeledUse : mu* -# 1029| v1029_11(void) = AliasedUse : ~m1029_2 -# 1029| v1029_12(void) = ExitFunction : - -# 1031| void Lambda(int, String const&) -# 1031| Block 0 -# 1031| v1031_1(void) = EnterFunction : -# 1031| m1031_2(unknown) = AliasedDefinition : -# 1031| mu1031_3(unknown) = UnmodeledDefinition : -# 1031| r1031_4(glval) = VariableAddress[x] : -# 1031| m1031_5(int) = InitializeParameter[x] : &:r1031_4 -# 1031| r1031_6(glval) = VariableAddress[s] : -# 1031| m1031_7(String &) = InitializeParameter[s] : &:r1031_6 -# 1031| r1031_8(String &) = Load : &:r1031_6, m1031_7 -# 1031| m1031_9(unknown) = InitializeIndirection[s] : &:r1031_8 -# 1031| m1031_10(unknown) = Chi : total:m1031_2, partial:m1031_9 -# 1032| r1032_1(glval) = VariableAddress[lambda_empty] : -# 1032| r1032_2(glval) = VariableAddress[#temp1032:23] : -# 1032| m1032_3(decltype([...](...){...})) = Uninitialized[#temp1032:23] : &:r1032_2 -# 1032| r1032_4(decltype([...](...){...})) = Load : &:r1032_2, m1032_3 -# 1032| m1032_5(decltype([...](...){...})) = Store : &:r1032_1, r1032_4 -# 1033| r1033_1(char) = Constant[65] : -# 1034| r1034_1(glval) = VariableAddress[lambda_ref] : -# 1034| r1034_2(glval) = VariableAddress[#temp1034:20] : -# 1034| m1034_3(decltype([...](...){...})) = Uninitialized[#temp1034:20] : &:r1034_2 -# 1034| r1034_4(glval) = FieldAddress[s] : r1034_2 -#-----| r0_1(glval) = VariableAddress[s] : -#-----| r0_2(String &) = Load : &:r0_1, m1031_7 -# 1034| r1034_5(glval) = CopyValue : r0_2 -# 1034| r1034_6(String &) = CopyValue : r1034_5 -# 1034| m1034_7(String &) = Store : &:r1034_4, r1034_6 -# 1034| m1034_8(decltype([...](...){...})) = Chi : total:m1034_3, partial:m1034_7 -# 1034| r1034_9(glval) = FieldAddress[x] : r1034_2 -#-----| r0_3(glval) = VariableAddress[x] : -#-----| r0_4(int &) = CopyValue : r0_3 -#-----| m0_5(int &) = Store : &:r1034_9, r0_4 -#-----| m0_6(decltype([...](...){...})) = Chi : total:m1034_8, partial:m0_5 -# 1034| r1034_10(decltype([...](...){...})) = Load : &:r1034_2, ~m0_6 -# 1034| m1034_11(decltype([...](...){...})) = Store : &:r1034_1, r1034_10 -# 1035| r1035_1(glval) = VariableAddress[lambda_ref] : -# 1035| r1035_2(glval) = Convert : r1035_1 -# 1035| r1035_3(glval) = FunctionAddress[operator()] : -# 1035| r1035_4(float) = Constant[1.0] : -# 1035| r1035_5(char) = Call : func:r1035_3, this:r1035_2, 0:r1035_4 -# 1035| m1035_6(unknown) = ^CallSideEffect : ~m1031_10 -# 1035| m1035_7(unknown) = Chi : total:m1031_10, partial:m1035_6 -# 1035| v1035_8(void) = ^BufferReadSideEffect[-1] : &:r1035_2, ~m1034_11 -# 1035| m1035_9(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1035_2 -# 1035| m1035_10(decltype([...](...){...})) = Chi : total:m1034_11, partial:m1035_9 -# 1036| r1036_1(glval) = VariableAddress[lambda_val] : -# 1036| r1036_2(glval) = VariableAddress[#temp1036:20] : -# 1036| m1036_3(decltype([...](...){...})) = Uninitialized[#temp1036:20] : &:r1036_2 -# 1036| r1036_4(glval) = FieldAddress[s] : r1036_2 -#-----| r0_7(glval) = FunctionAddress[String] : -#-----| v0_8(void) = Call : func:r0_7, this:r1036_4 -#-----| m0_9(unknown) = ^CallSideEffect : ~m1035_7 -#-----| m0_10(unknown) = Chi : total:m1035_7, partial:m0_9 -#-----| m0_11(String) = ^IndirectMayWriteSideEffect[-1] : &:r1036_4 -#-----| m0_12(decltype([...](...){...})) = Chi : total:m1036_3, partial:m0_11 -# 1036| r1036_5(glval) = FieldAddress[x] : r1036_2 -#-----| r0_13(glval) = VariableAddress[x] : -#-----| r0_14(int) = Load : &:r0_13, m1031_5 -#-----| m0_15(int) = Store : &:r1036_5, r0_14 -#-----| m0_16(decltype([...](...){...})) = Chi : total:m0_12, partial:m0_15 -# 1036| r1036_6(decltype([...](...){...})) = Load : &:r1036_2, ~m0_16 -# 1036| m1036_7(decltype([...](...){...})) = Store : &:r1036_1, r1036_6 -# 1037| r1037_1(glval) = VariableAddress[lambda_val] : -# 1037| r1037_2(glval) = Convert : r1037_1 -# 1037| r1037_3(glval) = FunctionAddress[operator()] : -# 1037| r1037_4(float) = Constant[2.0] : -# 1037| r1037_5(char) = Call : func:r1037_3, this:r1037_2, 0:r1037_4 -# 1037| m1037_6(unknown) = ^CallSideEffect : ~m0_10 -# 1037| m1037_7(unknown) = Chi : total:m0_10, partial:m1037_6 -# 1037| v1037_8(void) = ^BufferReadSideEffect[-1] : &:r1037_2, ~m1036_7 -# 1037| m1037_9(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1037_2 -# 1037| m1037_10(decltype([...](...){...})) = Chi : total:m1036_7, partial:m1037_9 -# 1038| r1038_1(glval) = VariableAddress[lambda_ref_explicit] : -# 1038| r1038_2(glval) = VariableAddress[#temp1038:29] : -# 1038| m1038_3(decltype([...](...){...})) = Uninitialized[#temp1038:29] : &:r1038_2 -# 1038| r1038_4(glval) = FieldAddress[s] : r1038_2 -# 1038| r1038_5(glval) = VariableAddress[s] : -# 1038| r1038_6(String &) = Load : &:r1038_5, m1031_7 -# 1038| r1038_7(glval) = CopyValue : r1038_6 -# 1038| r1038_8(String &) = CopyValue : r1038_7 -# 1038| m1038_9(String &) = Store : &:r1038_4, r1038_8 -# 1038| r1038_10(decltype([...](...){...})) = Load : &:r1038_2, ~m1038_9 -# 1038| m1038_11(decltype([...](...){...})) = Store : &:r1038_1, r1038_10 -# 1039| r1039_1(glval) = VariableAddress[lambda_ref_explicit] : -# 1039| r1039_2(glval) = Convert : r1039_1 -# 1039| r1039_3(glval) = FunctionAddress[operator()] : -# 1039| r1039_4(float) = Constant[3.0] : -# 1039| r1039_5(char) = Call : func:r1039_3, this:r1039_2, 0:r1039_4 -# 1039| m1039_6(unknown) = ^CallSideEffect : ~m1037_7 -# 1039| m1039_7(unknown) = Chi : total:m1037_7, partial:m1039_6 -# 1039| v1039_8(void) = ^BufferReadSideEffect[-1] : &:r1039_2, ~m1038_11 -# 1039| m1039_9(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1039_2 -# 1039| m1039_10(decltype([...](...){...})) = Chi : total:m1038_11, partial:m1039_9 -# 1040| r1040_1(glval) = VariableAddress[lambda_val_explicit] : -# 1040| r1040_2(glval) = VariableAddress[#temp1040:29] : -# 1040| m1040_3(decltype([...](...){...})) = Uninitialized[#temp1040:29] : &:r1040_2 -# 1040| r1040_4(glval) = FieldAddress[s] : r1040_2 -#-----| r0_17(glval) = FunctionAddress[String] : -#-----| v0_18(void) = Call : func:r0_17, this:r1040_4 -#-----| m0_19(unknown) = ^CallSideEffect : ~m1039_7 -#-----| m0_20(unknown) = Chi : total:m1039_7, partial:m0_19 -#-----| m0_21(String) = ^IndirectMayWriteSideEffect[-1] : &:r1040_4 -#-----| m0_22(decltype([...](...){...})) = Chi : total:m1040_3, partial:m0_21 -# 1040| r1040_5(decltype([...](...){...})) = Load : &:r1040_2, ~m0_22 -# 1040| m1040_6(decltype([...](...){...})) = Store : &:r1040_1, r1040_5 -# 1041| r1041_1(glval) = VariableAddress[lambda_val_explicit] : -# 1041| r1041_2(glval) = Convert : r1041_1 -# 1041| r1041_3(glval) = FunctionAddress[operator()] : -# 1041| r1041_4(float) = Constant[4.0] : -# 1041| r1041_5(char) = Call : func:r1041_3, this:r1041_2, 0:r1041_4 -# 1041| m1041_6(unknown) = ^CallSideEffect : ~m0_20 -# 1041| m1041_7(unknown) = Chi : total:m0_20, partial:m1041_6 -# 1041| v1041_8(void) = ^BufferReadSideEffect[-1] : &:r1041_2, ~m1040_6 -# 1041| m1041_9(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1041_2 -# 1041| m1041_10(decltype([...](...){...})) = Chi : total:m1040_6, partial:m1041_9 -# 1042| r1042_1(glval) = VariableAddress[lambda_mixed_explicit] : -# 1042| r1042_2(glval) = VariableAddress[#temp1042:31] : -# 1042| m1042_3(decltype([...](...){...})) = Uninitialized[#temp1042:31] : &:r1042_2 -# 1042| r1042_4(glval) = FieldAddress[s] : r1042_2 -# 1042| r1042_5(glval) = VariableAddress[s] : -# 1042| r1042_6(String &) = Load : &:r1042_5, m1031_7 -# 1042| r1042_7(glval) = CopyValue : r1042_6 -# 1042| r1042_8(String &) = CopyValue : r1042_7 -# 1042| m1042_9(String &) = Store : &:r1042_4, r1042_8 -# 1042| m1042_10(decltype([...](...){...})) = Chi : total:m1042_3, partial:m1042_9 -# 1042| r1042_11(glval) = FieldAddress[x] : r1042_2 -# 1042| r1042_12(glval) = VariableAddress[x] : -# 1042| r1042_13(int) = Load : &:r1042_12, m1031_5 -# 1042| m1042_14(int) = Store : &:r1042_11, r1042_13 -# 1042| m1042_15(decltype([...](...){...})) = Chi : total:m1042_10, partial:m1042_14 -# 1042| r1042_16(decltype([...](...){...})) = Load : &:r1042_2, ~m1042_15 -# 1042| m1042_17(decltype([...](...){...})) = Store : &:r1042_1, r1042_16 -# 1043| r1043_1(glval) = VariableAddress[lambda_mixed_explicit] : -# 1043| r1043_2(glval) = Convert : r1043_1 -# 1043| r1043_3(glval) = FunctionAddress[operator()] : -# 1043| r1043_4(float) = Constant[5.0] : -# 1043| r1043_5(char) = Call : func:r1043_3, this:r1043_2, 0:r1043_4 -# 1043| m1043_6(unknown) = ^CallSideEffect : ~m1041_7 -# 1043| m1043_7(unknown) = Chi : total:m1041_7, partial:m1043_6 -# 1043| v1043_8(void) = ^BufferReadSideEffect[-1] : &:r1043_2, ~m1042_17 -# 1043| m1043_9(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1043_2 -# 1043| m1043_10(decltype([...](...){...})) = Chi : total:m1042_17, partial:m1043_9 -# 1044| r1044_1(glval) = VariableAddress[r] : -# 1044| r1044_2(glval) = VariableAddress[x] : -# 1044| r1044_3(int) = Load : &:r1044_2, m1031_5 -# 1044| r1044_4(int) = Constant[1] : -# 1044| r1044_5(int) = Sub : r1044_3, r1044_4 -# 1044| m1044_6(int) = Store : &:r1044_1, r1044_5 -# 1045| r1045_1(glval) = VariableAddress[lambda_inits] : -# 1045| r1045_2(glval) = VariableAddress[#temp1045:22] : -# 1045| m1045_3(decltype([...](...){...})) = Uninitialized[#temp1045:22] : &:r1045_2 -# 1045| r1045_4(glval) = FieldAddress[s] : r1045_2 -# 1045| r1045_5(glval) = VariableAddress[s] : -# 1045| r1045_6(String &) = Load : &:r1045_5, m1031_7 -# 1045| r1045_7(glval) = CopyValue : r1045_6 -# 1045| r1045_8(String &) = CopyValue : r1045_7 -# 1045| m1045_9(String &) = Store : &:r1045_4, r1045_8 -# 1045| m1045_10(decltype([...](...){...})) = Chi : total:m1045_3, partial:m1045_9 -# 1045| r1045_11(glval) = FieldAddress[x] : r1045_2 -# 1045| r1045_12(glval) = VariableAddress[x] : -# 1045| r1045_13(int) = Load : &:r1045_12, m1031_5 -# 1045| m1045_14(int) = Store : &:r1045_11, r1045_13 -# 1045| m1045_15(decltype([...](...){...})) = Chi : total:m1045_10, partial:m1045_14 -# 1045| r1045_16(glval) = FieldAddress[i] : r1045_2 -# 1045| r1045_17(glval) = VariableAddress[x] : -# 1045| r1045_18(int) = Load : &:r1045_17, m1031_5 -# 1045| r1045_19(int) = Constant[1] : -# 1045| r1045_20(int) = Add : r1045_18, r1045_19 -# 1045| m1045_21(int) = Store : &:r1045_16, r1045_20 -# 1045| m1045_22(decltype([...](...){...})) = Chi : total:m1045_15, partial:m1045_21 -# 1045| r1045_23(glval) = FieldAddress[j] : r1045_2 -# 1045| r1045_24(glval) = VariableAddress[r] : -# 1045| r1045_25(int &) = CopyValue : r1045_24 -# 1045| m1045_26(int &) = Store : &:r1045_23, r1045_25 -# 1045| m1045_27(decltype([...](...){...})) = Chi : total:m1045_22, partial:m1045_26 -# 1045| r1045_28(decltype([...](...){...})) = Load : &:r1045_2, ~m1045_27 -# 1045| m1045_29(decltype([...](...){...})) = Store : &:r1045_1, r1045_28 -# 1046| r1046_1(glval) = VariableAddress[lambda_inits] : -# 1046| r1046_2(glval) = Convert : r1046_1 -# 1046| r1046_3(glval) = FunctionAddress[operator()] : -# 1046| r1046_4(float) = Constant[6.0] : -# 1046| r1046_5(char) = Call : func:r1046_3, this:r1046_2, 0:r1046_4 -# 1046| m1046_6(unknown) = ^CallSideEffect : ~m1043_7 -# 1046| m1046_7(unknown) = Chi : total:m1043_7, partial:m1046_6 -# 1046| v1046_8(void) = ^BufferReadSideEffect[-1] : &:r1046_2, ~m1045_29 -# 1046| m1046_9(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1046_2 -# 1046| m1046_10(decltype([...](...){...})) = Chi : total:m1045_29, partial:m1046_9 -# 1047| v1047_1(void) = NoOp : -# 1031| v1031_11(void) = ReturnIndirection : &:r1031_8, ~m1046_7 -# 1031| v1031_12(void) = ReturnVoid : -# 1031| v1031_13(void) = UnmodeledUse : mu* -# 1031| v1031_14(void) = AliasedUse : ~m1046_7 -# 1031| v1031_15(void) = ExitFunction : - -# 1032| char (void Lambda(int, String const&))::(lambda [] type at line 1032, col. 23)::operator()(float) const -# 1032| Block 0 -# 1032| v1032_1(void) = EnterFunction : -# 1032| m1032_2(unknown) = AliasedDefinition : -# 1032| mu1032_3(unknown) = UnmodeledDefinition : -# 1032| r1032_4(glval) = InitializeThis : -# 1032| r1032_5(glval) = VariableAddress[f] : -# 1032| m1032_6(float) = InitializeParameter[f] : &:r1032_5 -# 1032| r1032_7(glval) = VariableAddress[#return] : -# 1032| r1032_8(char) = Constant[65] : -# 1032| m1032_9(char) = Store : &:r1032_7, r1032_8 -# 1032| r1032_10(glval) = VariableAddress[#return] : -# 1032| v1032_11(void) = ReturnValue : &:r1032_10, m1032_9 -# 1032| v1032_12(void) = UnmodeledUse : mu* -# 1032| v1032_13(void) = AliasedUse : ~m1032_2 -# 1032| v1032_14(void) = ExitFunction : - -# 1032| char(* (void Lambda(int, String const&))::(lambda [] type at line 1032, col. 23)::operator char (*)(float)() const)(float) -# 1032| Block 0 -# 1032| v1032_1(void) = EnterFunction : -# 1032| m1032_2(unknown) = AliasedDefinition : -# 1032| mu1032_3(unknown) = UnmodeledDefinition : -# 1032| r1032_4(glval) = InitializeThis : -# 1032| r1032_5(glval<..(*)(..)>) = VariableAddress[#return] : -# 1032| r1032_6(..(*)(..)) = FunctionAddress[_FUN] : -# 1032| m1032_7(..(*)(..)) = Store : &:r1032_5, r1032_6 -# 1032| r1032_8(glval<..(*)(..)>) = VariableAddress[#return] : -# 1032| v1032_9(void) = ReturnValue : &:r1032_8, m1032_7 -# 1032| v1032_10(void) = UnmodeledUse : mu* -# 1032| v1032_11(void) = AliasedUse : ~m1032_2 -# 1032| v1032_12(void) = ExitFunction : - -# 1034| char (void Lambda(int, String const&))::(lambda [] type at line 1034, col. 21)::operator()(float) const -# 1034| Block 0 -# 1034| v1034_1(void) = EnterFunction : -# 1034| m1034_2(unknown) = AliasedDefinition : -# 1034| mu1034_3(unknown) = UnmodeledDefinition : -# 1034| r1034_4(glval) = InitializeThis : -# 1034| r1034_5(glval) = VariableAddress[f] : -# 1034| m1034_6(float) = InitializeParameter[f] : &:r1034_5 -# 1034| r1034_7(glval) = VariableAddress[#return] : -#-----| r0_1(lambda [] type at line 1034, col. 21 *) = CopyValue : r1034_4 -#-----| r0_2(glval) = FieldAddress[s] : r0_1 -#-----| r0_3(String &) = Load : &:r0_2, ~m1034_2 -# 1034| r1034_8(glval) = CopyValue : r0_3 -# 1034| r1034_9(glval) = FunctionAddress[c_str] : -# 1034| r1034_10(char *) = Call : func:r1034_9, this:r1034_8 -# 1034| m1034_11(unknown) = ^CallSideEffect : ~m1034_2 -# 1034| m1034_12(unknown) = Chi : total:m1034_2, partial:m1034_11 -# 1034| v1034_13(void) = ^BufferReadSideEffect[-1] : &:r1034_8, ~m1034_12 -# 1034| m1034_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r1034_8 -# 1034| m1034_15(unknown) = Chi : total:m1034_12, partial:m1034_14 -#-----| r0_4(lambda [] type at line 1034, col. 21 *) = CopyValue : r1034_4 -#-----| r0_5(glval) = FieldAddress[x] : r0_4 -#-----| r0_6(int &) = Load : &:r0_5, ~m1034_15 -# 1034| r1034_16(int) = Load : &:r0_6, ~m1034_15 -# 1034| r1034_17(glval) = PointerAdd[1] : r1034_10, r1034_16 -# 1034| r1034_18(char) = Load : &:r1034_17, ~m1034_15 -# 1034| m1034_19(char) = Store : &:r1034_7, r1034_18 -# 1034| r1034_20(glval) = VariableAddress[#return] : -# 1034| v1034_21(void) = ReturnValue : &:r1034_20, m1034_19 -# 1034| v1034_22(void) = UnmodeledUse : mu* -# 1034| v1034_23(void) = AliasedUse : ~m1034_15 -# 1034| v1034_24(void) = ExitFunction : - -# 1036| void (void Lambda(int, String const&))::(lambda [] type at line 1036, col. 21)::~() -# 1036| Block 0 -# 1036| v1036_1(void) = EnterFunction : -# 1036| m1036_2(unknown) = AliasedDefinition : -# 1036| mu1036_3(unknown) = UnmodeledDefinition : -# 1036| r1036_4(glval) = InitializeThis : -#-----| v0_1(void) = NoOp : -# 1036| r1036_5(glval) = FieldAddress[s] : r1036_4 -# 1036| r1036_6(glval) = FunctionAddress[~String] : -# 1036| v1036_7(void) = Call : func:r1036_6, this:r1036_5 -# 1036| m1036_8(unknown) = ^CallSideEffect : ~m1036_2 -# 1036| m1036_9(unknown) = Chi : total:m1036_2, partial:m1036_8 -# 1036| v1036_10(void) = ReturnVoid : -# 1036| v1036_11(void) = UnmodeledUse : mu* -# 1036| v1036_12(void) = AliasedUse : ~m1036_9 -# 1036| v1036_13(void) = ExitFunction : - -# 1036| char (void Lambda(int, String const&))::(lambda [] type at line 1036, col. 21)::operator()(float) const -# 1036| Block 0 -# 1036| v1036_1(void) = EnterFunction : -# 1036| m1036_2(unknown) = AliasedDefinition : -# 1036| mu1036_3(unknown) = UnmodeledDefinition : -# 1036| r1036_4(glval) = InitializeThis : -# 1036| r1036_5(glval) = VariableAddress[f] : -# 1036| m1036_6(float) = InitializeParameter[f] : &:r1036_5 -# 1036| r1036_7(glval) = VariableAddress[#return] : -#-----| r0_1(lambda [] type at line 1036, col. 21 *) = CopyValue : r1036_4 -#-----| r0_2(glval) = FieldAddress[s] : r0_1 -# 1036| r1036_8(glval) = FunctionAddress[c_str] : -# 1036| r1036_9(char *) = Call : func:r1036_8, this:r0_2 -# 1036| m1036_10(unknown) = ^CallSideEffect : ~m1036_2 -# 1036| m1036_11(unknown) = Chi : total:m1036_2, partial:m1036_10 -#-----| v0_3(void) = ^BufferReadSideEffect[-1] : &:r0_2, ~m1036_11 -#-----| m0_4(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_2 -#-----| m0_5(unknown) = Chi : total:m1036_11, partial:m0_4 -#-----| r0_6(lambda [] type at line 1036, col. 21 *) = CopyValue : r1036_4 -#-----| r0_7(glval) = FieldAddress[x] : r0_6 -#-----| r0_8(int) = Load : &:r0_7, ~m0_5 -# 1036| r1036_12(glval) = PointerAdd[1] : r1036_9, r0_8 -# 1036| r1036_13(char) = Load : &:r1036_12, ~m0_5 -# 1036| m1036_14(char) = Store : &:r1036_7, r1036_13 -# 1036| r1036_15(glval) = VariableAddress[#return] : -# 1036| v1036_16(void) = ReturnValue : &:r1036_15, m1036_14 -# 1036| v1036_17(void) = UnmodeledUse : mu* -# 1036| v1036_18(void) = AliasedUse : ~m0_5 -# 1036| v1036_19(void) = ExitFunction : - -# 1038| char (void Lambda(int, String const&))::(lambda [] type at line 1038, col. 30)::operator()(float) const -# 1038| Block 0 -# 1038| v1038_1(void) = EnterFunction : -# 1038| m1038_2(unknown) = AliasedDefinition : -# 1038| mu1038_3(unknown) = UnmodeledDefinition : -# 1038| r1038_4(glval) = InitializeThis : -# 1038| r1038_5(glval) = VariableAddress[f] : -# 1038| m1038_6(float) = InitializeParameter[f] : &:r1038_5 -# 1038| r1038_7(glval) = VariableAddress[#return] : -#-----| r0_1(lambda [] type at line 1038, col. 30 *) = CopyValue : r1038_4 -#-----| r0_2(glval) = FieldAddress[s] : r0_1 -#-----| r0_3(String &) = Load : &:r0_2, ~m1038_2 -# 1038| r1038_8(glval) = CopyValue : r0_3 -# 1038| r1038_9(glval) = FunctionAddress[c_str] : -# 1038| r1038_10(char *) = Call : func:r1038_9, this:r1038_8 -# 1038| m1038_11(unknown) = ^CallSideEffect : ~m1038_2 -# 1038| m1038_12(unknown) = Chi : total:m1038_2, partial:m1038_11 -# 1038| v1038_13(void) = ^BufferReadSideEffect[-1] : &:r1038_8, ~m1038_12 -# 1038| m1038_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r1038_8 -# 1038| m1038_15(unknown) = Chi : total:m1038_12, partial:m1038_14 -# 1038| r1038_16(int) = Constant[0] : -# 1038| r1038_17(glval) = PointerAdd[1] : r1038_10, r1038_16 -# 1038| r1038_18(char) = Load : &:r1038_17, ~m1038_15 -# 1038| m1038_19(char) = Store : &:r1038_7, r1038_18 -# 1038| r1038_20(glval) = VariableAddress[#return] : -# 1038| v1038_21(void) = ReturnValue : &:r1038_20, m1038_19 -# 1038| v1038_22(void) = UnmodeledUse : mu* -# 1038| v1038_23(void) = AliasedUse : ~m1038_15 -# 1038| v1038_24(void) = ExitFunction : - -# 1040| void (void Lambda(int, String const&))::(lambda [] type at line 1040, col. 30)::~() -# 1040| Block 0 -# 1040| v1040_1(void) = EnterFunction : -# 1040| m1040_2(unknown) = AliasedDefinition : -# 1040| mu1040_3(unknown) = UnmodeledDefinition : -# 1040| r1040_4(glval) = InitializeThis : -#-----| v0_1(void) = NoOp : -# 1040| r1040_5(glval) = FieldAddress[s] : r1040_4 -# 1040| r1040_6(glval) = FunctionAddress[~String] : -# 1040| v1040_7(void) = Call : func:r1040_6, this:r1040_5 -# 1040| m1040_8(unknown) = ^CallSideEffect : ~m1040_2 -# 1040| m1040_9(unknown) = Chi : total:m1040_2, partial:m1040_8 -# 1040| v1040_10(void) = ReturnVoid : -# 1040| v1040_11(void) = UnmodeledUse : mu* -# 1040| v1040_12(void) = AliasedUse : ~m1040_9 -# 1040| v1040_13(void) = ExitFunction : - -# 1040| char (void Lambda(int, String const&))::(lambda [] type at line 1040, col. 30)::operator()(float) const -# 1040| Block 0 -# 1040| v1040_1(void) = EnterFunction : -# 1040| m1040_2(unknown) = AliasedDefinition : -# 1040| mu1040_3(unknown) = UnmodeledDefinition : -# 1040| r1040_4(glval) = InitializeThis : -# 1040| r1040_5(glval) = VariableAddress[f] : -# 1040| m1040_6(float) = InitializeParameter[f] : &:r1040_5 -# 1040| r1040_7(glval) = VariableAddress[#return] : -#-----| r0_1(lambda [] type at line 1040, col. 30 *) = CopyValue : r1040_4 -#-----| r0_2(glval) = FieldAddress[s] : r0_1 -# 1040| r1040_8(glval) = FunctionAddress[c_str] : -# 1040| r1040_9(char *) = Call : func:r1040_8, this:r0_2 -# 1040| m1040_10(unknown) = ^CallSideEffect : ~m1040_2 -# 1040| m1040_11(unknown) = Chi : total:m1040_2, partial:m1040_10 -#-----| v0_3(void) = ^BufferReadSideEffect[-1] : &:r0_2, ~m1040_11 -#-----| m0_4(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_2 -#-----| m0_5(unknown) = Chi : total:m1040_11, partial:m0_4 -# 1040| r1040_12(int) = Constant[0] : -# 1040| r1040_13(glval) = PointerAdd[1] : r1040_9, r1040_12 -# 1040| r1040_14(char) = Load : &:r1040_13, ~m0_5 -# 1040| m1040_15(char) = Store : &:r1040_7, r1040_14 -# 1040| r1040_16(glval) = VariableAddress[#return] : -# 1040| v1040_17(void) = ReturnValue : &:r1040_16, m1040_15 -# 1040| v1040_18(void) = UnmodeledUse : mu* -# 1040| v1040_19(void) = AliasedUse : ~m0_5 -# 1040| v1040_20(void) = ExitFunction : - -# 1042| char (void Lambda(int, String const&))::(lambda [] type at line 1042, col. 32)::operator()(float) const -# 1042| Block 0 -# 1042| v1042_1(void) = EnterFunction : -# 1042| m1042_2(unknown) = AliasedDefinition : -# 1042| mu1042_3(unknown) = UnmodeledDefinition : -# 1042| r1042_4(glval) = InitializeThis : -# 1042| r1042_5(glval) = VariableAddress[f] : -# 1042| m1042_6(float) = InitializeParameter[f] : &:r1042_5 -# 1042| r1042_7(glval) = VariableAddress[#return] : -#-----| r0_1(lambda [] type at line 1042, col. 32 *) = CopyValue : r1042_4 -#-----| r0_2(glval) = FieldAddress[s] : r0_1 -#-----| r0_3(String &) = Load : &:r0_2, ~m1042_2 -# 1042| r1042_8(glval) = CopyValue : r0_3 -# 1042| r1042_9(glval) = FunctionAddress[c_str] : -# 1042| r1042_10(char *) = Call : func:r1042_9, this:r1042_8 -# 1042| m1042_11(unknown) = ^CallSideEffect : ~m1042_2 -# 1042| m1042_12(unknown) = Chi : total:m1042_2, partial:m1042_11 -# 1042| v1042_13(void) = ^BufferReadSideEffect[-1] : &:r1042_8, ~m1042_12 -# 1042| m1042_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r1042_8 -# 1042| m1042_15(unknown) = Chi : total:m1042_12, partial:m1042_14 -#-----| r0_4(lambda [] type at line 1042, col. 32 *) = CopyValue : r1042_4 -#-----| r0_5(glval) = FieldAddress[x] : r0_4 -#-----| r0_6(int) = Load : &:r0_5, ~m1042_15 -# 1042| r1042_16(glval) = PointerAdd[1] : r1042_10, r0_6 -# 1042| r1042_17(char) = Load : &:r1042_16, ~m1042_15 -# 1042| m1042_18(char) = Store : &:r1042_7, r1042_17 -# 1042| r1042_19(glval) = VariableAddress[#return] : -# 1042| v1042_20(void) = ReturnValue : &:r1042_19, m1042_18 -# 1042| v1042_21(void) = UnmodeledUse : mu* -# 1042| v1042_22(void) = AliasedUse : ~m1042_15 -# 1042| v1042_23(void) = ExitFunction : - -# 1045| char (void Lambda(int, String const&))::(lambda [] type at line 1045, col. 23)::operator()(float) const -# 1045| Block 0 -# 1045| v1045_1(void) = EnterFunction : -# 1045| m1045_2(unknown) = AliasedDefinition : -# 1045| mu1045_3(unknown) = UnmodeledDefinition : -# 1045| r1045_4(glval) = InitializeThis : -# 1045| r1045_5(glval) = VariableAddress[f] : -# 1045| m1045_6(float) = InitializeParameter[f] : &:r1045_5 -# 1045| r1045_7(glval) = VariableAddress[#return] : -#-----| r0_1(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 -#-----| r0_2(glval) = FieldAddress[s] : r0_1 -#-----| r0_3(String &) = Load : &:r0_2, ~m1045_2 -# 1045| r1045_8(glval) = CopyValue : r0_3 -# 1045| r1045_9(glval) = FunctionAddress[c_str] : -# 1045| r1045_10(char *) = Call : func:r1045_9, this:r1045_8 -# 1045| m1045_11(unknown) = ^CallSideEffect : ~m1045_2 -# 1045| m1045_12(unknown) = Chi : total:m1045_2, partial:m1045_11 -# 1045| v1045_13(void) = ^BufferReadSideEffect[-1] : &:r1045_8, ~m1045_12 -# 1045| m1045_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r1045_8 -# 1045| m1045_15(unknown) = Chi : total:m1045_12, partial:m1045_14 -#-----| r0_4(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 -#-----| r0_5(glval) = FieldAddress[x] : r0_4 -#-----| r0_6(int) = Load : &:r0_5, ~m1045_15 -#-----| r0_7(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 -# 1045| r1045_16(glval) = FieldAddress[i] : r0_7 -# 1045| r1045_17(int) = Load : &:r1045_16, ~m1045_15 -# 1045| r1045_18(int) = Add : r0_6, r1045_17 -#-----| r0_8(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 -# 1045| r1045_19(glval) = FieldAddress[j] : r0_8 -# 1045| r1045_20(int &) = Load : &:r1045_19, ~m1045_15 -# 1045| r1045_21(int) = Load : &:r1045_20, ~m1045_15 -# 1045| r1045_22(int) = Sub : r1045_18, r1045_21 -# 1045| r1045_23(glval) = PointerAdd[1] : r1045_10, r1045_22 -# 1045| r1045_24(char) = Load : &:r1045_23, ~m1045_15 -# 1045| m1045_25(char) = Store : &:r1045_7, r1045_24 -# 1045| r1045_26(glval) = VariableAddress[#return] : -# 1045| v1045_27(void) = ReturnValue : &:r1045_26, m1045_25 -# 1045| v1045_28(void) = UnmodeledUse : mu* -# 1045| v1045_29(void) = AliasedUse : ~m1045_15 -# 1045| v1045_30(void) = ExitFunction : - -# 1068| void RangeBasedFor(vector const&) -# 1068| Block 0 -# 1068| v1068_1(void) = EnterFunction : -# 1068| m1068_2(unknown) = AliasedDefinition : -# 1068| mu1068_3(unknown) = UnmodeledDefinition : -# 1068| r1068_4(glval &>) = VariableAddress[v] : -# 1068| m1068_5(vector &) = InitializeParameter[v] : &:r1068_4 -# 1068| r1068_6(vector &) = Load : &:r1068_4, m1068_5 -# 1068| m1068_7(unknown) = InitializeIndirection[v] : &:r1068_6 -# 1068| m1068_8(unknown) = Chi : total:m1068_2, partial:m1068_7 -# 1069| r1069_1(glval &>) = VariableAddress[(__range)] : -# 1069| r1069_2(glval &>) = VariableAddress[v] : -# 1069| r1069_3(vector &) = Load : &:r1069_2, m1068_5 -# 1069| r1069_4(glval>) = CopyValue : r1069_3 -# 1069| r1069_5(vector &) = CopyValue : r1069_4 -# 1069| m1069_6(vector &) = Store : &:r1069_1, r1069_5 -# 1069| r1069_7(glval) = VariableAddress[(__begin)] : -#-----| r0_1(glval &>) = VariableAddress[(__range)] : -#-----| r0_2(vector &) = Load : &:r0_1, m1069_6 -#-----| r0_3(glval>) = CopyValue : r0_2 -# 1069| r1069_8(glval) = FunctionAddress[begin] : -# 1069| r1069_9(iterator) = Call : func:r1069_8, this:r0_3 -# 1069| m1069_10(unknown) = ^CallSideEffect : ~m1068_8 -# 1069| m1069_11(unknown) = Chi : total:m1068_8, partial:m1069_10 -#-----| v0_4(void) = ^BufferReadSideEffect[-1] : &:r0_3, ~m1069_11 -#-----| m0_5(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_3 -#-----| m0_6(unknown) = Chi : total:m1069_11, partial:m0_5 -# 1069| m1069_12(iterator) = Store : &:r1069_7, r1069_9 -# 1069| r1069_13(glval) = VariableAddress[(__end)] : -#-----| r0_7(glval &>) = VariableAddress[(__range)] : -#-----| r0_8(vector &) = Load : &:r0_7, m1069_6 -#-----| r0_9(glval>) = CopyValue : r0_8 -# 1069| r1069_14(glval) = FunctionAddress[end] : -# 1069| r1069_15(iterator) = Call : func:r1069_14, this:r0_9 -# 1069| m1069_16(unknown) = ^CallSideEffect : ~m0_6 -# 1069| m1069_17(unknown) = Chi : total:m0_6, partial:m1069_16 -#-----| v0_10(void) = ^BufferReadSideEffect[-1] : &:r0_9, ~m1069_17 -#-----| m0_11(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_9 -#-----| m0_12(unknown) = Chi : total:m1069_17, partial:m0_11 -# 1069| m1069_18(iterator) = Store : &:r1069_13, r1069_15 -#-----| Goto -> Block 6 - -#-----| Block 1 -#-----| m0_13(iterator) = Phi : from 2:m0_25, from 10:m1075_31 -#-----| m0_14(unknown) = Phi : from 2:~m1075_9, from 10:~m0_60 -#-----| r0_15(glval) = VariableAddress[(__begin)] : -#-----| r0_16(glval) = Convert : r0_15 -# 1075| r1075_1(glval) = FunctionAddress[operator!=] : -#-----| r0_17(glval) = VariableAddress[(__end)] : -#-----| r0_18(iterator) = Load : &:r0_17, m1075_37 -# 1075| r1075_2(bool) = Call : func:r1075_1, this:r0_16, 0:r0_18 -# 1075| m1075_3(unknown) = ^CallSideEffect : ~m0_14 -# 1075| m1075_4(unknown) = Chi : total:m0_14, partial:m1075_3 -#-----| v0_19(void) = ^BufferReadSideEffect[-1] : &:r0_16, ~m0_13 -#-----| m0_20(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_16 -#-----| m0_21(iterator) = Chi : total:m0_13, partial:m0_20 -# 1075| v1075_5(void) = ConditionalBranch : r1075_2 -#-----| False -> Block 5 -#-----| True -> Block 3 - -#-----| Block 2 -#-----| r0_22(glval) = VariableAddress[(__begin)] : -# 1075| r1075_6(glval) = FunctionAddress[operator++] : -# 1075| r1075_7(iterator &) = Call : func:r1075_6, this:r0_22 -# 1075| m1075_8(unknown) = ^CallSideEffect : ~m1075_15 -# 1075| m1075_9(unknown) = Chi : total:m1075_15, partial:m1075_8 -#-----| v0_23(void) = ^BufferReadSideEffect[-1] : &:r0_22, ~m0_30 -#-----| m0_24(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_22 -#-----| m0_25(iterator) = Chi : total:m0_30, partial:m0_24 -# 1075| r1075_10(glval) = CopyValue : r1075_7 -#-----| Goto (back edge) -> Block 1 - -# 1075| Block 3 -# 1075| r1075_11(glval) = VariableAddress[e] : -#-----| r0_26(glval) = VariableAddress[(__begin)] : -#-----| r0_27(glval) = Convert : r0_26 -# 1075| r1075_12(glval) = FunctionAddress[operator*] : -# 1075| r1075_13(int &) = Call : func:r1075_12, this:r0_27 -# 1075| m1075_14(unknown) = ^CallSideEffect : ~m1075_4 -# 1075| m1075_15(unknown) = Chi : total:m1075_4, partial:m1075_14 -#-----| v0_28(void) = ^BufferReadSideEffect[-1] : &:r0_27, ~m0_21 -#-----| m0_29(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_27 -#-----| m0_30(iterator) = Chi : total:m0_21, partial:m0_29 -# 1075| r1075_16(glval) = CopyValue : r1075_13 -# 1075| r1075_17(glval) = Convert : r1075_16 -# 1075| r1075_18(int &) = CopyValue : r1075_17 -# 1075| m1075_19(int &) = Store : &:r1075_11, r1075_18 -# 1076| r1076_1(glval) = VariableAddress[e] : -# 1076| r1076_2(int &) = Load : &:r1076_1, m1075_19 -# 1076| r1076_3(int) = Load : &:r1076_2, ~m1075_15 -# 1076| r1076_4(int) = Constant[5] : -# 1076| r1076_5(bool) = CompareLT : r1076_3, r1076_4 -# 1076| v1076_6(void) = ConditionalBranch : r1076_5 -#-----| False -> Block 2 -#-----| True -> Block 4 - -# 1077| Block 4 -# 1077| v1077_1(void) = NoOp : -#-----| Goto -> Block 5 - -# 1079| Block 5 -# 1079| m1079_1(unknown) = Phi : from 1:~m1075_4, from 4:~m1075_15 -# 1079| v1079_2(void) = NoOp : -# 1080| v1080_1(void) = NoOp : -# 1068| v1068_9(void) = ReturnIndirection : &:r1068_6, ~m1079_1 -# 1068| v1068_10(void) = ReturnVoid : -# 1068| v1068_11(void) = UnmodeledUse : mu* -# 1068| v1068_12(void) = AliasedUse : ~m1079_1 -# 1068| v1068_13(void) = ExitFunction : - -#-----| Block 6 -#-----| m0_31(iterator) = Phi : from 0:m1069_12, from 9:m0_48 -#-----| m0_32(unknown) = Phi : from 0:~m0_12, from 9:~m1069_35 -#-----| r0_33(glval) = VariableAddress[(__begin)] : -#-----| r0_34(glval) = Convert : r0_33 -# 1069| r1069_19(glval) = FunctionAddress[operator!=] : -#-----| r0_35(glval) = VariableAddress[(__end)] : -#-----| r0_36(iterator) = Load : &:r0_35, m1069_18 -# 1069| r1069_20(bool) = Call : func:r1069_19, this:r0_34, 0:r0_36 -# 1069| m1069_21(unknown) = ^CallSideEffect : ~m0_32 -# 1069| m1069_22(unknown) = Chi : total:m0_32, partial:m1069_21 -#-----| v0_37(void) = ^BufferReadSideEffect[-1] : &:r0_34, ~m0_31 -#-----| m0_38(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_34 -#-----| m0_39(iterator) = Chi : total:m0_31, partial:m0_38 -# 1069| v1069_23(void) = ConditionalBranch : r1069_20 -#-----| False -> Block 10 -#-----| True -> Block 7 - -# 1069| Block 7 -# 1069| r1069_24(glval) = VariableAddress[e] : -#-----| r0_40(glval) = VariableAddress[(__begin)] : -#-----| r0_41(glval) = Convert : r0_40 -# 1069| r1069_25(glval) = FunctionAddress[operator*] : -# 1069| r1069_26(int &) = Call : func:r1069_25, this:r0_41 -# 1069| m1069_27(unknown) = ^CallSideEffect : ~m1069_22 -# 1069| m1069_28(unknown) = Chi : total:m1069_22, partial:m1069_27 -#-----| v0_42(void) = ^BufferReadSideEffect[-1] : &:r0_41, ~m0_39 -#-----| m0_43(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_41 -#-----| m0_44(iterator) = Chi : total:m0_39, partial:m0_43 -# 1069| r1069_29(int) = Load : &:r1069_26, ~m1069_28 -# 1069| m1069_30(int) = Store : &:r1069_24, r1069_29 -# 1070| r1070_1(glval) = VariableAddress[e] : -# 1070| r1070_2(int) = Load : &:r1070_1, m1069_30 -# 1070| r1070_3(int) = Constant[0] : -# 1070| r1070_4(bool) = CompareGT : r1070_2, r1070_3 -# 1070| v1070_5(void) = ConditionalBranch : r1070_4 -#-----| False -> Block 9 -#-----| True -> Block 8 - -# 1071| Block 8 -# 1071| v1071_1(void) = NoOp : -#-----| Goto -> Block 9 - -# 1069| Block 9 -# 1069| v1069_31(void) = NoOp : -#-----| r0_45(glval) = VariableAddress[(__begin)] : -# 1069| r1069_32(glval) = FunctionAddress[operator++] : -# 1069| r1069_33(iterator &) = Call : func:r1069_32, this:r0_45 -# 1069| m1069_34(unknown) = ^CallSideEffect : ~m1069_28 -# 1069| m1069_35(unknown) = Chi : total:m1069_28, partial:m1069_34 -#-----| v0_46(void) = ^BufferReadSideEffect[-1] : &:r0_45, ~m0_44 -#-----| m0_47(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_45 -#-----| m0_48(iterator) = Chi : total:m0_44, partial:m0_47 -# 1069| r1069_36(glval) = CopyValue : r1069_33 -#-----| Goto (back edge) -> Block 6 - -# 1075| Block 10 -# 1075| r1075_20(glval &>) = VariableAddress[(__range)] : -# 1075| r1075_21(glval &>) = VariableAddress[v] : -# 1075| r1075_22(vector &) = Load : &:r1075_21, m1068_5 -# 1075| r1075_23(glval>) = CopyValue : r1075_22 -# 1075| r1075_24(vector &) = CopyValue : r1075_23 -# 1075| m1075_25(vector &) = Store : &:r1075_20, r1075_24 -# 1075| r1075_26(glval) = VariableAddress[(__begin)] : -#-----| r0_49(glval &>) = VariableAddress[(__range)] : -#-----| r0_50(vector &) = Load : &:r0_49, m1075_25 -#-----| r0_51(glval>) = CopyValue : r0_50 -# 1075| r1075_27(glval) = FunctionAddress[begin] : -# 1075| r1075_28(iterator) = Call : func:r1075_27, this:r0_51 -# 1075| m1075_29(unknown) = ^CallSideEffect : ~m1069_22 -# 1075| m1075_30(unknown) = Chi : total:m1069_22, partial:m1075_29 -#-----| v0_52(void) = ^BufferReadSideEffect[-1] : &:r0_51, ~m1075_30 -#-----| m0_53(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_51 -#-----| m0_54(unknown) = Chi : total:m1075_30, partial:m0_53 -# 1075| m1075_31(iterator) = Store : &:r1075_26, r1075_28 -# 1075| r1075_32(glval) = VariableAddress[(__end)] : -#-----| r0_55(glval &>) = VariableAddress[(__range)] : -#-----| r0_56(vector &) = Load : &:r0_55, m1075_25 -#-----| r0_57(glval>) = CopyValue : r0_56 -# 1075| r1075_33(glval) = FunctionAddress[end] : -# 1075| r1075_34(iterator) = Call : func:r1075_33, this:r0_57 -# 1075| m1075_35(unknown) = ^CallSideEffect : ~m0_54 -# 1075| m1075_36(unknown) = Chi : total:m0_54, partial:m1075_35 -#-----| v0_58(void) = ^BufferReadSideEffect[-1] : &:r0_57, ~m1075_36 -#-----| m0_59(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_57 -#-----| m0_60(unknown) = Chi : total:m1075_36, partial:m0_59 -# 1075| m1075_37(iterator) = Store : &:r1075_32, r1075_34 -#-----| Goto -> Block 1 - -# 1099| int AsmStmt(int) -# 1099| Block 0 -# 1099| v1099_1(void) = EnterFunction : -# 1099| m1099_2(unknown) = AliasedDefinition : -# 1099| mu1099_3(unknown) = UnmodeledDefinition : -# 1099| r1099_4(glval) = VariableAddress[x] : -# 1099| m1099_5(int) = InitializeParameter[x] : &:r1099_4 -# 1100| m1100_1(unknown) = InlineAsm : ~m1099_2 -# 1100| m1100_2(unknown) = Chi : total:m1099_2, partial:m1100_1 -# 1101| r1101_1(glval) = VariableAddress[#return] : -# 1101| r1101_2(glval) = VariableAddress[x] : -# 1101| r1101_3(int) = Load : &:r1101_2, m1099_5 -# 1101| m1101_4(int) = Store : &:r1101_1, r1101_3 -# 1099| r1099_6(glval) = VariableAddress[#return] : -# 1099| v1099_7(void) = ReturnValue : &:r1099_6, m1101_4 -# 1099| v1099_8(void) = UnmodeledUse : mu* -# 1099| v1099_9(void) = AliasedUse : ~m1100_2 -# 1099| v1099_10(void) = ExitFunction : - -# 1104| void AsmStmtWithOutputs(unsigned int&, unsigned int, unsigned int&, unsigned int) -# 1104| Block 0 -# 1104| v1104_1(void) = EnterFunction : -# 1104| m1104_2(unknown) = AliasedDefinition : -# 1104| mu1104_3(unknown) = UnmodeledDefinition : -# 1104| r1104_4(glval) = VariableAddress[a] : -# 1104| m1104_5(unsigned int &) = InitializeParameter[a] : &:r1104_4 -# 1104| r1104_6(unsigned int &) = Load : &:r1104_4, m1104_5 -# 1104| m1104_7(unknown) = InitializeIndirection[a] : &:r1104_6 -# 1104| m1104_8(unknown) = Chi : total:m1104_2, partial:m1104_7 -# 1104| r1104_9(glval) = VariableAddress[b] : -# 1104| m1104_10(unsigned int) = InitializeParameter[b] : &:r1104_9 -# 1104| r1104_11(glval) = VariableAddress[c] : -# 1104| m1104_12(unsigned int &) = InitializeParameter[c] : &:r1104_11 -# 1104| r1104_13(unsigned int &) = Load : &:r1104_11, m1104_12 -# 1104| m1104_14(unknown) = InitializeIndirection[c] : &:r1104_13 -# 1104| m1104_15(unknown) = Chi : total:m1104_8, partial:m1104_14 -# 1104| r1104_16(glval) = VariableAddress[d] : -# 1104| m1104_17(unsigned int) = InitializeParameter[d] : &:r1104_16 -# 1109| r1109_1(glval) = VariableAddress[a] : -# 1109| r1109_2(unsigned int &) = Load : &:r1109_1, m1104_5 -# 1109| r1109_3(glval) = CopyValue : r1109_2 -# 1109| r1109_4(glval) = VariableAddress[b] : -# 1109| r1109_5(glval) = VariableAddress[c] : -# 1109| r1109_6(unsigned int &) = Load : &:r1109_5, m1104_12 -# 1109| r1109_7(unsigned int) = Load : &:r1109_6, ~m1104_15 -# 1109| r1109_8(glval) = VariableAddress[d] : -# 1109| r1109_9(unsigned int) = Load : &:r1109_8, m1104_17 -# 1106| m1106_1(unknown) = InlineAsm : ~m1104_15, 0:r1109_3, 1:r1109_4, 2:r1109_7, 3:r1109_9 -# 1106| m1106_2(unknown) = Chi : total:m1104_15, partial:m1106_1 -# 1111| v1111_1(void) = NoOp : -# 1104| v1104_18(void) = ReturnIndirection : &:r1104_6, ~m1106_2 -# 1104| v1104_19(void) = ReturnIndirection : &:r1104_13, ~m1106_2 -# 1104| v1104_20(void) = ReturnVoid : -# 1104| v1104_21(void) = UnmodeledUse : mu* -# 1104| v1104_22(void) = AliasedUse : ~m1106_2 -# 1104| v1104_23(void) = ExitFunction : - -# 1113| void ExternDeclarations() -# 1113| Block 0 -# 1113| v1113_1(void) = EnterFunction : -# 1113| m1113_2(unknown) = AliasedDefinition : -# 1113| mu1113_3(unknown) = UnmodeledDefinition : -# 1116| r1116_1(glval) = VariableAddress[x] : -# 1116| m1116_2(int) = Uninitialized[x] : &:r1116_1 -# 1117| r1117_1(glval) = VariableAddress[y] : -# 1117| m1117_2(int) = Uninitialized[y] : &:r1117_1 -# 1118| r1118_1(glval) = VariableAddress[h] : -# 1118| m1118_2(int) = Uninitialized[h] : &:r1118_1 -# 1120| v1120_1(void) = NoOp : -# 1113| v1113_4(void) = ReturnVoid : -# 1113| v1113_5(void) = UnmodeledUse : mu* -# 1113| v1113_6(void) = AliasedUse : ~m1113_2 -# 1113| v1113_7(void) = ExitFunction : - -# 1128| void ExternDeclarationsInMacro() -# 1128| Block 0 -# 1128| v1128_1(void) = EnterFunction : -# 1128| m1128_2(unknown) = AliasedDefinition : -# 1128| mu1128_3(unknown) = UnmodeledDefinition : -# 1130| r1130_1(glval) = VariableAddress[i] : -# 1130| r1130_2(int) = Constant[0] : -# 1130| m1130_3(int) = Store : &:r1130_1, r1130_2 -#-----| Goto -> Block 1 - -# 1130| Block 1 -# 1130| m1130_4(int) = Phi : from 0:m1130_3, from 2:m1130_14 -# 1130| r1130_5(glval) = VariableAddress[i] : -# 1130| r1130_6(int) = Load : &:r1130_5, m1130_4 -# 1130| r1130_7(int) = Constant[10] : -# 1130| r1130_8(bool) = CompareLT : r1130_6, r1130_7 -# 1130| v1130_9(void) = ConditionalBranch : r1130_8 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 1130| Block 2 -# 1130| r1130_10(glval) = VariableAddress[i] : -# 1130| r1130_11(int) = Load : &:r1130_10, m1130_4 -# 1130| r1130_12(int) = Constant[1] : -# 1130| r1130_13(int) = Add : r1130_11, r1130_12 -# 1130| m1130_14(int) = Store : &:r1130_10, r1130_13 -#-----| Goto (back edge) -> Block 1 - -# 1130| Block 3 -# 1130| v1130_15(void) = NoOp : -# 1131| v1131_1(void) = NoOp : -# 1128| v1128_4(void) = ReturnVoid : -# 1128| v1128_5(void) = UnmodeledUse : mu* -# 1128| v1128_6(void) = AliasedUse : ~m1128_2 -# 1128| v1128_7(void) = ExitFunction : - -# 1133| void TryCatchNoCatchAny(bool) -# 1133| Block 0 -# 1133| v1133_1(void) = EnterFunction : -# 1133| m1133_2(unknown) = AliasedDefinition : -# 1133| mu1133_3(unknown) = UnmodeledDefinition : -# 1133| r1133_4(glval) = VariableAddress[b] : -# 1133| m1133_5(bool) = InitializeParameter[b] : &:r1133_4 -# 1135| r1135_1(glval) = VariableAddress[x] : -# 1135| r1135_2(int) = Constant[5] : -# 1135| m1135_3(int) = Store : &:r1135_1, r1135_2 -# 1136| r1136_1(glval) = VariableAddress[b] : -# 1136| r1136_2(bool) = Load : &:r1136_1, m1133_5 -# 1136| v1136_3(void) = ConditionalBranch : r1136_2 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 1133| Block 1 -# 1133| m1133_6(unknown) = Phi : from 2:~m1133_10, from 10:~m1149_1 -# 1133| v1133_7(void) = UnmodeledUse : mu* -# 1133| v1133_8(void) = AliasedUse : ~m1133_6 -# 1133| v1133_9(void) = ExitFunction : - -# 1133| Block 2 -# 1133| m1133_10(unknown) = Phi : from 7:~m1145_13, from 8:~m1133_2 -# 1133| v1133_11(void) = Unwind : -#-----| Goto -> Block 1 - -# 1137| Block 3 -# 1137| r1137_1(glval) = VariableAddress[#throw1137:7] : -# 1137| r1137_2(glval) = StringConstant["string literal"] : -# 1137| r1137_3(char *) = Convert : r1137_2 -# 1137| m1137_4(char *) = Store : &:r1137_1, r1137_3 -# 1137| v1137_5(void) = ThrowValue : &:r1137_1, m1137_4 -#-----| Exception -> Block 6 - -# 1139| Block 4 -# 1139| r1139_1(glval) = VariableAddress[x] : -# 1139| r1139_2(int) = Load : &:r1139_1, m1135_3 -# 1139| r1139_3(int) = Constant[2] : -# 1139| r1139_4(bool) = CompareLT : r1139_2, r1139_3 -# 1139| v1139_5(void) = ConditionalBranch : r1139_4 -#-----| False -> Block 5 -#-----| True -> Block 11 - -# 1142| Block 5 -# 1142| r1142_1(int) = Constant[7] : -# 1142| r1142_2(glval) = VariableAddress[x] : -# 1142| m1142_3(int) = Store : &:r1142_2, r1142_1 -#-----| Goto -> Block 10 - -# 1144| Block 6 -# 1144| v1144_1(void) = CatchByType[const char *] : -#-----| Exception -> Block 8 -#-----| Goto -> Block 7 - -# 1144| Block 7 -# 1144| r1144_2(glval) = VariableAddress[s] : -# 1144| m1144_3(char *) = InitializeParameter[s] : &:r1144_2 -# 1144| r1144_4(char *) = Load : &:r1144_2, m1144_3 -# 1144| m1144_5(unknown) = InitializeIndirection[s] : &:r1144_4 -# 1144| m1144_6(unknown) = Chi : total:m1133_2, partial:m1144_5 -# 1145| r1145_1(glval) = VariableAddress[#throw1145:5] : -# 1145| m1145_2(String) = Uninitialized[#throw1145:5] : &:r1145_1 -# 1145| r1145_3(glval) = FunctionAddress[String] : -# 1145| r1145_4(glval) = VariableAddress[s] : -# 1145| r1145_5(char *) = Load : &:r1145_4, m1144_3 -# 1145| v1145_6(void) = Call : func:r1145_3, this:r1145_1, 0:r1145_5 -# 1145| m1145_7(unknown) = ^CallSideEffect : ~m1144_6 -# 1145| m1145_8(unknown) = Chi : total:m1144_6, partial:m1145_7 -# 1145| m1145_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r1145_1 -# 1145| m1145_10(String) = Chi : total:m1145_2, partial:m1145_9 -# 1145| v1145_11(void) = ^BufferReadSideEffect[0] : &:r1145_5, ~m1145_8 -# 1145| m1145_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r1145_5 -# 1145| m1145_13(unknown) = Chi : total:m1145_8, partial:m1145_12 -# 1145| v1145_14(void) = ThrowValue : &:r1145_1, ~m1145_10 -#-----| Exception -> Block 2 - -# 1147| Block 8 -# 1147| v1147_1(void) = CatchByType[const String &] : -#-----| Exception -> Block 2 -#-----| Goto -> Block 9 - -# 1147| Block 9 -# 1147| r1147_2(glval) = VariableAddress[e] : -# 1147| m1147_3(String &) = InitializeParameter[e] : &:r1147_2 -# 1147| r1147_4(String &) = Load : &:r1147_2, m1147_3 -# 1147| m1147_5(unknown) = InitializeIndirection[e] : &:r1147_4 -# 1147| m1147_6(unknown) = Chi : total:m1133_2, partial:m1147_5 -# 1147| v1147_7(void) = NoOp : -#-----| Goto -> Block 10 - -# 1149| Block 10 -# 1149| m1149_1(unknown) = Phi : from 5:~m1133_2, from 9:~m1147_6 -# 1149| v1149_2(void) = NoOp : -# 1133| v1133_12(void) = ReturnVoid : -#-----| Goto -> Block 1 - -# 1133| Block 11 -# 1133| v1133_13(void) = Unreached : - -# 1153| void VectorTypes(int) -# 1153| Block 0 -# 1153| v1153_1(void) = EnterFunction : -# 1153| m1153_2(unknown) = AliasedDefinition : -# 1153| mu1153_3(unknown) = UnmodeledDefinition : -# 1153| r1153_4(glval) = VariableAddress[i] : -# 1153| m1153_5(int) = InitializeParameter[i] : &:r1153_4 -# 1154| r1154_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1154| m1154_2(__attribute((vector_size(16UL))) int) = Uninitialized[vi4] : &:r1154_1 -# 1154| r1154_3(int) = Constant[0] : -# 1154| r1154_4(glval) = PointerAdd[4] : r1154_1, r1154_3 -# 1154| r1154_5(int) = Constant[0] : -# 1154| m1154_6(int) = Store : &:r1154_4, r1154_5 -# 1154| m1154_7(__attribute((vector_size(16UL))) int) = Chi : total:m1154_2, partial:m1154_6 -# 1154| r1154_8(int) = Constant[1] : -# 1154| r1154_9(glval) = PointerAdd[4] : r1154_1, r1154_8 -# 1154| r1154_10(int) = Constant[1] : -# 1154| m1154_11(int) = Store : &:r1154_9, r1154_10 -# 1154| m1154_12(__attribute((vector_size(16UL))) int) = Chi : total:m1154_7, partial:m1154_11 -# 1154| r1154_13(int) = Constant[2] : -# 1154| r1154_14(glval) = PointerAdd[4] : r1154_1, r1154_13 -# 1154| r1154_15(int) = Constant[2] : -# 1154| m1154_16(int) = Store : &:r1154_14, r1154_15 -# 1154| m1154_17(__attribute((vector_size(16UL))) int) = Chi : total:m1154_12, partial:m1154_16 -# 1154| r1154_18(int) = Constant[3] : -# 1154| r1154_19(glval) = PointerAdd[4] : r1154_1, r1154_18 -# 1154| r1154_20(int) = Constant[3] : -# 1154| m1154_21(int) = Store : &:r1154_19, r1154_20 -# 1154| m1154_22(__attribute((vector_size(16UL))) int) = Chi : total:m1154_17, partial:m1154_21 -# 1155| r1155_1(glval) = VariableAddress[x] : -# 1155| r1155_2(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1155| r1155_3(glval) = VariableAddress[i] : -# 1155| r1155_4(int) = Load : &:r1155_3, m1153_5 -# 1155| r1155_5(glval) = PointerAdd[4] : r1155_2, r1155_4 -# 1155| r1155_6(int) = Load : &:r1155_5, ~m1154_22 -# 1155| m1155_7(int) = Store : &:r1155_1, r1155_6 -# 1156| r1156_1(glval) = VariableAddress[x] : -# 1156| r1156_2(int) = Load : &:r1156_1, m1155_7 -# 1156| r1156_3(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1156| r1156_4(glval) = VariableAddress[i] : -# 1156| r1156_5(int) = Load : &:r1156_4, m1153_5 -# 1156| r1156_6(glval) = PointerAdd[4] : r1156_3, r1156_5 -# 1156| m1156_7(int) = Store : &:r1156_6, r1156_2 -# 1156| m1156_8(__attribute((vector_size(16UL))) int) = Chi : total:m1154_22, partial:m1156_7 -# 1157| r1157_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4_shuffle] : -# 1157| r1157_2(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1157| r1157_3(__attribute((vector_size(16UL))) int) = Load : &:r1157_2, ~m1156_8 -# 1157| r1157_4(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1157| r1157_5(__attribute((vector_size(16UL))) int) = Load : &:r1157_4, ~m1156_8 -#-----| r0_1(int) = Constant[3] : -# 1157| r1157_6(int) = Constant[2] : -# 1157| r1157_7(int) = Constant[1] : -# 1157| r1157_8(int) = Constant[0] : -# 1157| r1157_9(__attribute((vector_size(16))) int) = BuiltIn[__builtin_shufflevector] : 0:r1157_3, 1:r1157_5, 2:r0_1, 3:r1157_6, 4:r1157_7, 5:r1157_8 -# 1157| m1157_10(__attribute((vector_size(16UL))) int) = Store : &:r1157_1, r1157_9 -# 1158| r1158_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1158| r1158_2(__attribute((vector_size(16UL))) int) = Load : &:r1158_1, ~m1156_8 -# 1158| r1158_3(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4_shuffle] : -# 1158| r1158_4(__attribute((vector_size(16UL))) int) = Load : &:r1158_3, m1157_10 -# 1158| r1158_5(__attribute((vector_size(16UL))) int) = Add : r1158_2, r1158_4 -# 1158| r1158_6(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1158| m1158_7(__attribute((vector_size(16UL))) int) = Store : &:r1158_6, r1158_5 -# 1159| v1159_1(void) = NoOp : -# 1153| v1153_6(void) = ReturnVoid : -# 1153| v1153_7(void) = UnmodeledUse : mu* -# 1153| v1153_8(void) = AliasedUse : ~m1153_2 -# 1153| v1153_9(void) = ExitFunction : - -# 1163| int ModeledCallTarget(int) -# 1163| Block 0 -# 1163| v1163_1(void) = EnterFunction : -# 1163| m1163_2(unknown) = AliasedDefinition : -# 1163| mu1163_3(unknown) = UnmodeledDefinition : -# 1163| r1163_4(glval) = VariableAddress[x] : -# 1163| m1163_5(int) = InitializeParameter[x] : &:r1163_4 -# 1164| r1164_1(glval) = VariableAddress[y] : -# 1164| m1164_2(int) = Uninitialized[y] : &:r1164_1 -# 1165| r1165_1(glval) = FunctionAddress[memcpy] : -# 1165| r1165_2(glval) = VariableAddress[y] : -# 1165| r1165_3(int *) = CopyValue : r1165_2 -# 1165| r1165_4(void *) = Convert : r1165_3 -# 1165| r1165_5(glval) = VariableAddress[x] : -# 1165| r1165_6(int *) = CopyValue : r1165_5 -# 1165| r1165_7(void *) = Convert : r1165_6 -# 1165| r1165_8(int) = Constant[4] : -# 1165| r1165_9(void *) = Call : func:r1165_1, 0:r1165_4, 1:r1165_7, 2:r1165_8 -# 1165| v1165_10(void) = ^SizedBufferReadSideEffect[1] : &:r1165_7, r1165_8, ~m1163_5 -# 1165| m1165_11(unknown) = ^SizedBufferMustWriteSideEffect[0] : &:r1165_4, r1165_8 -# 1165| m1165_12(int) = Chi : total:m1164_2, partial:m1165_11 -# 1166| r1166_1(glval) = VariableAddress[#return] : -# 1166| r1166_2(glval) = VariableAddress[y] : -# 1166| r1166_3(int) = Load : &:r1166_2, ~m1165_12 -# 1166| m1166_4(int) = Store : &:r1166_1, r1166_3 -# 1163| r1163_6(glval) = VariableAddress[#return] : -# 1163| v1163_7(void) = ReturnValue : &:r1163_6, m1166_4 -# 1163| v1163_8(void) = UnmodeledUse : mu* -# 1163| v1163_9(void) = AliasedUse : ~m1163_2 -# 1163| v1163_10(void) = ExitFunction : - -# 1169| String ReturnObjectImpl() -# 1169| Block 0 -# 1169| v1169_1(void) = EnterFunction : -# 1169| m1169_2(unknown) = AliasedDefinition : -# 1169| mu1169_3(unknown) = UnmodeledDefinition : -# 1170| r1170_1(glval) = VariableAddress[#return] : -# 1170| m1170_2(String) = Uninitialized[#return] : &:r1170_1 -# 1170| r1170_3(glval) = FunctionAddress[String] : -# 1170| r1170_4(glval) = StringConstant["foo"] : -# 1170| r1170_5(char *) = Convert : r1170_4 -# 1170| r1170_6(String) = Call : func:r1170_3, this:r1170_1, 0:r1170_5 -# 1170| m1170_7(unknown) = ^CallSideEffect : ~m1169_2 -# 1170| m1170_8(unknown) = Chi : total:m1169_2, partial:m1170_7 -# 1170| m1170_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r1170_1 -# 1170| m1170_10(String) = Chi : total:m1170_2, partial:m1170_9 -# 1170| v1170_11(void) = ^BufferReadSideEffect[0] : &:r1170_5, ~m1169_2 -# 1170| m1170_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r1170_5 -# 1170| m1170_13(unknown) = Chi : total:m1170_8, partial:m1170_12 -# 1169| r1169_4(glval) = VariableAddress[#return] : -# 1169| v1169_5(void) = ReturnValue : &:r1169_4, ~m1170_10 -# 1169| v1169_6(void) = UnmodeledUse : mu* -# 1169| v1169_7(void) = AliasedUse : ~m1170_13 -# 1169| v1169_8(void) = ExitFunction : - -perf-regression.cpp: -# 6| void Big::Big() -# 6| Block 0 -# 6| v6_1(void) = EnterFunction : -# 6| m6_2(unknown) = AliasedDefinition : -# 6| mu6_3(unknown) = UnmodeledDefinition : -# 6| r6_4(glval) = InitializeThis : -# 6| r6_5(glval) = FieldAddress[buffer] : r6_4 -# 6| r6_6(int) = Constant[0] : -# 6| r6_7(glval) = PointerAdd[1] : r6_5, r6_6 -# 6| r6_8(unknown[1073741824]) = Constant[0] : -# 6| m6_9(unknown[1073741824]) = Store : &:r6_7, r6_8 -# 6| m6_10(unknown) = Chi : total:m6_2, partial:m6_9 -# 6| v6_11(void) = NoOp : -# 6| v6_12(void) = ReturnVoid : -# 6| v6_13(void) = UnmodeledUse : mu* -# 6| v6_14(void) = AliasedUse : ~m6_10 -# 6| v6_15(void) = ExitFunction : - -# 9| int main() -# 9| Block 0 -# 9| v9_1(void) = EnterFunction : -# 9| m9_2(unknown) = AliasedDefinition : -# 9| mu9_3(unknown) = UnmodeledDefinition : -# 10| r10_1(glval) = VariableAddress[big] : -# 10| r10_2(glval) = FunctionAddress[operator new] : -# 10| r10_3(unsigned long) = Constant[1073741824] : -# 10| r10_4(void *) = Call : func:r10_2, 0:r10_3 -# 10| m10_5(unknown) = ^CallSideEffect : ~m9_2 -# 10| m10_6(unknown) = Chi : total:m9_2, partial:m10_5 -# 10| r10_7(Big *) = Convert : r10_4 -# 10| r10_8(glval) = FunctionAddress[Big] : -# 10| v10_9(void) = Call : func:r10_8, this:r10_7 -# 10| m10_10(unknown) = ^CallSideEffect : ~m10_6 -# 10| m10_11(unknown) = Chi : total:m10_6, partial:m10_10 -# 10| m10_12(Big) = ^IndirectMayWriteSideEffect[-1] : &:r10_7 -# 10| m10_13(unknown) = Chi : total:m10_11, partial:m10_12 -# 10| m10_14(Big *) = Store : &:r10_1, r10_7 -# 12| r12_1(glval) = VariableAddress[#return] : -# 12| r12_2(int) = Constant[0] : -# 12| m12_3(int) = Store : &:r12_1, r12_2 -# 9| r9_4(glval) = VariableAddress[#return] : -# 9| v9_5(void) = ReturnValue : &:r9_4, m12_3 -# 9| v9_6(void) = UnmodeledUse : mu* -# 9| v9_7(void) = AliasedUse : ~m10_13 -# 9| v9_8(void) = ExitFunction : diff --git a/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.qlref b/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.qlref deleted file mode 100644 index b9f65b3881d..00000000000 --- a/cpp/ql/test/library-tests/ir/ir/aliased_ssa_ir.qlref +++ /dev/null @@ -1 +0,0 @@ -semmle/code/cpp/ir/implementation/aliased_ssa/PrintIR.ql \ No newline at end of file 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 deleted file mode 100644 index 0724fbfafb4..00000000000 --- a/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.expected +++ /dev/null @@ -1,5926 +0,0 @@ -bad_asts.cpp: -# 9| int Bad::S::MemberFunction(int) -# 9| Block 0 -# 9| v9_1(void) = EnterFunction : -# 9| mu9_2(unknown) = AliasedDefinition : -# 9| mu9_3(unknown) = UnmodeledDefinition : -# 9| r9_4(glval) = InitializeThis : -# 9| r9_5(glval) = VariableAddress[y] : -# 9| m9_6(int) = InitializeParameter[y] : &:r9_5 -# 10| r10_1(glval) = VariableAddress[#return] : -# 10| r10_2(int) = Constant[6] : -#-----| r0_1(S *) = CopyValue : r9_4 -# 10| r10_3(glval) = FieldAddress[x] : r0_1 -# 10| r10_4(int) = Load : &:r10_3, ~mu9_3 -# 10| r10_5(int) = Add : r10_2, r10_4 -# 10| r10_6(glval) = VariableAddress[y] : -# 10| r10_7(int) = Load : &:r10_6, m9_6 -# 10| r10_8(int) = Add : r10_5, r10_7 -# 10| m10_9(int) = Store : &:r10_1, r10_8 -# 9| r9_7(glval) = VariableAddress[#return] : -# 9| v9_8(void) = ReturnValue : &:r9_7, m10_9 -# 9| v9_9(void) = UnmodeledUse : mu* -# 9| v9_10(void) = AliasedUse : ~mu9_3 -# 9| v9_11(void) = ExitFunction : - -# 14| void Bad::CallBadMemberFunction() -# 14| Block 0 -# 14| v14_1(void) = EnterFunction : -# 14| mu14_2(unknown) = AliasedDefinition : -# 14| mu14_3(unknown) = UnmodeledDefinition : -# 15| r15_1(glval) = VariableAddress[s] : -# 15| mu15_2(S) = Uninitialized[s] : &:r15_1 -# 15| r15_3(glval) = FieldAddress[x] : r15_1 -# 15| r15_4(int) = Constant[0] : -# 15| mu15_5(int) = Store : &:r15_3, r15_4 -# 16| r16_1(glval) = VariableAddress[s] : -# 16| r16_2(glval) = FunctionAddress[MemberFunction] : -# 16| r16_3(int) = Constant[1] : -# 16| r16_4(int) = Call : func:r16_2, this:r16_1, 0:r16_3 -# 16| mu16_5(unknown) = ^CallSideEffect : ~mu14_3 -# 16| v16_6(void) = ^BufferReadSideEffect[-1] : &:r16_1, ~mu14_3 -# 16| mu16_7(S) = ^IndirectMayWriteSideEffect[-1] : &:r16_1 -# 17| v17_1(void) = NoOp : -# 14| v14_4(void) = ReturnVoid : -# 14| v14_5(void) = UnmodeledUse : mu* -# 14| v14_6(void) = AliasedUse : ~mu14_3 -# 14| v14_7(void) = ExitFunction : - -# 22| void Bad::Point::Point() -# 22| Block 0 -# 22| v22_1(void) = EnterFunction : -# 22| mu22_2(unknown) = AliasedDefinition : -# 22| mu22_3(unknown) = UnmodeledDefinition : -# 22| r22_4(glval) = InitializeThis : -# 23| v23_1(void) = NoOp : -# 22| v22_5(void) = ReturnVoid : -# 22| v22_6(void) = UnmodeledUse : mu* -# 22| v22_7(void) = AliasedUse : ~mu22_3 -# 22| v22_8(void) = ExitFunction : - -# 26| void Bad::CallCopyConstructor(Bad::Point const&) -# 26| Block 0 -# 26| v26_1(void) = EnterFunction : -# 26| mu26_2(unknown) = AliasedDefinition : -# 26| mu26_3(unknown) = UnmodeledDefinition : -# 26| r26_4(glval) = VariableAddress[a] : -# 26| m26_5(Point &) = InitializeParameter[a] : &:r26_4 -# 26| r26_6(Point &) = Load : &:r26_4, m26_5 -# 26| mu26_7(unknown) = InitializeIndirection[a] : &:r26_6 -# 27| r27_1(glval) = VariableAddress[b] : -# 27| r27_2(glval) = VariableAddress[a] : -# 27| r27_3(Point &) = Load : &:r27_2, m26_5 -# 27| r27_4(glval) = CopyValue : r27_3 -# 27| r27_5(glval) = Convert : r27_4 -# 27| r27_6(Point) = Load : &:r27_5, ~mu26_3 -# 27| m27_7(Point) = Store : &:r27_1, r27_6 -# 28| v28_1(void) = NoOp : -# 26| v26_8(void) = ReturnIndirection : &:r26_6, ~mu26_3 -# 26| v26_9(void) = ReturnVoid : -# 26| v26_10(void) = UnmodeledUse : mu* -# 26| v26_11(void) = AliasedUse : ~mu26_3 -# 26| v26_12(void) = ExitFunction : - -# 30| void Bad::errorExpr() -# 30| Block 0 -# 30| v30_1(void) = EnterFunction : -# 30| mu30_2(unknown) = AliasedDefinition : -# 30| mu30_3(unknown) = UnmodeledDefinition : -# 31| r31_1(glval) = VariableAddress[intref] : -# 31| r31_2(error) = Error : -# 31| m31_3(int &) = Store : &:r31_1, r31_2 -# 32| r32_1(glval) = VariableAddress[x] : -# 32| r32_2(error) = Error : -# 32| m32_3(int) = Store : &:r32_1, r32_2 -#-----| r0_1(glval) = Error : -#-----| r0_2(error) = Load : &:r0_1, ~mu30_3 -# 33| r33_1(glval) = VariableAddress[x] : -# 33| m33_2(int) = Store : &:r33_1, r0_2 -# 34| v34_1(void) = NoOp : -# 30| v30_4(void) = ReturnVoid : -# 30| v30_5(void) = UnmodeledUse : mu* -# 30| v30_6(void) = AliasedUse : ~mu30_3 -# 30| v30_7(void) = ExitFunction : - -clang.cpp: -# 5| int* globalIntAddress() -# 5| Block 0 -# 5| v5_1(void) = EnterFunction : -# 5| mu5_2(unknown) = AliasedDefinition : -# 5| mu5_3(unknown) = UnmodeledDefinition : -# 6| r6_1(glval) = VariableAddress[#return] : -# 6| r6_2(glval) = VariableAddress[globalInt] : -# 6| r6_3(int *) = CopyValue : r6_2 -# 6| m6_4(int *) = Store : &:r6_1, r6_3 -# 5| r5_4(glval) = VariableAddress[#return] : -# 5| v5_5(void) = ReturnValue : &:r5_4, m6_4 -# 5| v5_6(void) = UnmodeledUse : mu* -# 5| v5_7(void) = AliasedUse : ~mu5_3 -# 5| v5_8(void) = ExitFunction : - -ir.cpp: -# 1| void Constants() -# 1| Block 0 -# 1| v1_1(void) = EnterFunction : -# 1| mu1_2(unknown) = AliasedDefinition : -# 1| mu1_3(unknown) = UnmodeledDefinition : -# 2| r2_1(glval) = VariableAddress[c_i] : -# 2| r2_2(char) = Constant[1] : -# 2| m2_3(char) = Store : &:r2_1, r2_2 -# 3| r3_1(glval) = VariableAddress[c_c] : -# 3| r3_2(char) = Constant[65] : -# 3| m3_3(char) = Store : &:r3_1, r3_2 -# 5| r5_1(glval) = VariableAddress[sc_i] : -# 5| r5_2(signed char) = Constant[-1] : -# 5| m5_3(signed char) = Store : &:r5_1, r5_2 -# 6| r6_1(glval) = VariableAddress[sc_c] : -# 6| r6_2(signed char) = Constant[65] : -# 6| m6_3(signed char) = Store : &:r6_1, r6_2 -# 8| r8_1(glval) = VariableAddress[uc_i] : -# 8| r8_2(unsigned char) = Constant[5] : -# 8| m8_3(unsigned char) = Store : &:r8_1, r8_2 -# 9| r9_1(glval) = VariableAddress[uc_c] : -# 9| r9_2(unsigned char) = Constant[65] : -# 9| m9_3(unsigned char) = Store : &:r9_1, r9_2 -# 11| r11_1(glval) = VariableAddress[s] : -# 11| r11_2(short) = Constant[5] : -# 11| m11_3(short) = Store : &:r11_1, r11_2 -# 12| r12_1(glval) = VariableAddress[us] : -# 12| r12_2(unsigned short) = Constant[5] : -# 12| m12_3(unsigned short) = Store : &:r12_1, r12_2 -# 14| r14_1(glval) = VariableAddress[i] : -# 14| r14_2(int) = Constant[5] : -# 14| m14_3(int) = Store : &:r14_1, r14_2 -# 15| r15_1(glval) = VariableAddress[ui] : -# 15| r15_2(unsigned int) = Constant[5] : -# 15| m15_3(unsigned int) = Store : &:r15_1, r15_2 -# 17| r17_1(glval) = VariableAddress[l] : -# 17| r17_2(long) = Constant[5] : -# 17| m17_3(long) = Store : &:r17_1, r17_2 -# 18| r18_1(glval) = VariableAddress[ul] : -# 18| r18_2(unsigned long) = Constant[5] : -# 18| m18_3(unsigned long) = Store : &:r18_1, r18_2 -# 20| r20_1(glval) = VariableAddress[ll_i] : -# 20| r20_2(long long) = Constant[5] : -# 20| m20_3(long long) = Store : &:r20_1, r20_2 -# 21| r21_1(glval) = VariableAddress[ll_ll] : -# 21| r21_2(long long) = Constant[5] : -# 21| m21_3(long long) = Store : &:r21_1, r21_2 -# 22| r22_1(glval) = VariableAddress[ull_i] : -# 22| r22_2(unsigned long long) = Constant[5] : -# 22| m22_3(unsigned long long) = Store : &:r22_1, r22_2 -# 23| r23_1(glval) = VariableAddress[ull_ull] : -# 23| r23_2(unsigned long long) = Constant[5] : -# 23| m23_3(unsigned long long) = Store : &:r23_1, r23_2 -# 25| r25_1(glval) = VariableAddress[b_t] : -# 25| r25_2(bool) = Constant[1] : -# 25| m25_3(bool) = Store : &:r25_1, r25_2 -# 26| r26_1(glval) = VariableAddress[b_f] : -# 26| r26_2(bool) = Constant[0] : -# 26| m26_3(bool) = Store : &:r26_1, r26_2 -# 28| r28_1(glval) = VariableAddress[wc_i] : -# 28| r28_2(wchar_t) = Constant[5] : -# 28| m28_3(wchar_t) = Store : &:r28_1, r28_2 -# 29| r29_1(glval) = VariableAddress[wc_c] : -# 29| r29_2(wchar_t) = Constant[65] : -# 29| m29_3(wchar_t) = Store : &:r29_1, r29_2 -# 31| r31_1(glval) = VariableAddress[c16] : -# 31| r31_2(char16_t) = Constant[65] : -# 31| m31_3(char16_t) = Store : &:r31_1, r31_2 -# 32| r32_1(glval) = VariableAddress[c32] : -# 32| r32_2(char32_t) = Constant[65] : -# 32| m32_3(char32_t) = Store : &:r32_1, r32_2 -# 34| r34_1(glval) = VariableAddress[f_i] : -# 34| r34_2(float) = Constant[1.0] : -# 34| m34_3(float) = Store : &:r34_1, r34_2 -# 35| r35_1(glval) = VariableAddress[f_f] : -# 35| r35_2(float) = Constant[1.0] : -# 35| m35_3(float) = Store : &:r35_1, r35_2 -# 36| r36_1(glval) = VariableAddress[f_d] : -# 36| r36_2(float) = Constant[1.0] : -# 36| m36_3(float) = Store : &:r36_1, r36_2 -# 38| r38_1(glval) = VariableAddress[d_i] : -# 38| r38_2(double) = Constant[1.0] : -# 38| m38_3(double) = Store : &:r38_1, r38_2 -# 39| r39_1(glval) = VariableAddress[d_f] : -# 39| r39_2(double) = Constant[1.0] : -# 39| m39_3(double) = Store : &:r39_1, r39_2 -# 40| r40_1(glval) = VariableAddress[d_d] : -# 40| r40_2(double) = Constant[1.0] : -# 40| m40_3(double) = Store : &:r40_1, r40_2 -# 41| v41_1(void) = NoOp : -# 1| v1_4(void) = ReturnVoid : -# 1| v1_5(void) = UnmodeledUse : mu* -# 1| v1_6(void) = AliasedUse : ~mu1_3 -# 1| v1_7(void) = ExitFunction : - -# 43| void Foo() -# 43| Block 0 -# 43| v43_1(void) = EnterFunction : -# 43| mu43_2(unknown) = AliasedDefinition : -# 43| mu43_3(unknown) = UnmodeledDefinition : -# 44| r44_1(glval) = VariableAddress[x] : -# 44| r44_2(int) = Constant[17] : -# 44| m44_3(int) = Store : &:r44_1, r44_2 -# 45| r45_1(glval) = VariableAddress[y] : -# 45| r45_2(short) = Constant[7] : -# 45| m45_3(short) = Store : &:r45_1, r45_2 -# 46| r46_1(glval) = VariableAddress[x] : -# 46| r46_2(int) = Load : &:r46_1, m44_3 -# 46| r46_3(glval) = VariableAddress[y] : -# 46| r46_4(short) = Load : &:r46_3, m45_3 -# 46| r46_5(int) = Convert : r46_4 -# 46| r46_6(int) = Add : r46_2, r46_5 -# 46| r46_7(short) = Convert : r46_6 -# 46| r46_8(glval) = VariableAddress[y] : -# 46| m46_9(short) = Store : &:r46_8, r46_7 -# 47| r47_1(glval) = VariableAddress[x] : -# 47| r47_2(int) = Load : &:r47_1, m44_3 -# 47| r47_3(glval) = VariableAddress[y] : -# 47| r47_4(short) = Load : &:r47_3, m46_9 -# 47| r47_5(int) = Convert : r47_4 -# 47| r47_6(int) = Mul : r47_2, r47_5 -# 47| r47_7(glval) = VariableAddress[x] : -# 47| m47_8(int) = Store : &:r47_7, r47_6 -# 48| v48_1(void) = NoOp : -# 43| v43_4(void) = ReturnVoid : -# 43| v43_5(void) = UnmodeledUse : mu* -# 43| v43_6(void) = AliasedUse : ~mu43_3 -# 43| v43_7(void) = ExitFunction : - -# 50| void IntegerOps(int, int) -# 50| Block 0 -# 50| v50_1(void) = EnterFunction : -# 50| mu50_2(unknown) = AliasedDefinition : -# 50| mu50_3(unknown) = UnmodeledDefinition : -# 50| r50_4(glval) = VariableAddress[x] : -# 50| m50_5(int) = InitializeParameter[x] : &:r50_4 -# 50| r50_6(glval) = VariableAddress[y] : -# 50| m50_7(int) = InitializeParameter[y] : &:r50_6 -# 51| r51_1(glval) = VariableAddress[z] : -# 51| m51_2(int) = Uninitialized[z] : &:r51_1 -# 53| r53_1(glval) = VariableAddress[x] : -# 53| r53_2(int) = Load : &:r53_1, m50_5 -# 53| r53_3(glval) = VariableAddress[y] : -# 53| r53_4(int) = Load : &:r53_3, m50_7 -# 53| r53_5(int) = Add : r53_2, r53_4 -# 53| r53_6(glval) = VariableAddress[z] : -# 53| m53_7(int) = Store : &:r53_6, r53_5 -# 54| r54_1(glval) = VariableAddress[x] : -# 54| r54_2(int) = Load : &:r54_1, m50_5 -# 54| r54_3(glval) = VariableAddress[y] : -# 54| r54_4(int) = Load : &:r54_3, m50_7 -# 54| r54_5(int) = Sub : r54_2, r54_4 -# 54| r54_6(glval) = VariableAddress[z] : -# 54| m54_7(int) = Store : &:r54_6, r54_5 -# 55| r55_1(glval) = VariableAddress[x] : -# 55| r55_2(int) = Load : &:r55_1, m50_5 -# 55| r55_3(glval) = VariableAddress[y] : -# 55| r55_4(int) = Load : &:r55_3, m50_7 -# 55| r55_5(int) = Mul : r55_2, r55_4 -# 55| r55_6(glval) = VariableAddress[z] : -# 55| m55_7(int) = Store : &:r55_6, r55_5 -# 56| r56_1(glval) = VariableAddress[x] : -# 56| r56_2(int) = Load : &:r56_1, m50_5 -# 56| r56_3(glval) = VariableAddress[y] : -# 56| r56_4(int) = Load : &:r56_3, m50_7 -# 56| r56_5(int) = Div : r56_2, r56_4 -# 56| r56_6(glval) = VariableAddress[z] : -# 56| m56_7(int) = Store : &:r56_6, r56_5 -# 57| r57_1(glval) = VariableAddress[x] : -# 57| r57_2(int) = Load : &:r57_1, m50_5 -# 57| r57_3(glval) = VariableAddress[y] : -# 57| r57_4(int) = Load : &:r57_3, m50_7 -# 57| r57_5(int) = Rem : r57_2, r57_4 -# 57| r57_6(glval) = VariableAddress[z] : -# 57| m57_7(int) = Store : &:r57_6, r57_5 -# 59| r59_1(glval) = VariableAddress[x] : -# 59| r59_2(int) = Load : &:r59_1, m50_5 -# 59| r59_3(glval) = VariableAddress[y] : -# 59| r59_4(int) = Load : &:r59_3, m50_7 -# 59| r59_5(int) = BitAnd : r59_2, r59_4 -# 59| r59_6(glval) = VariableAddress[z] : -# 59| m59_7(int) = Store : &:r59_6, r59_5 -# 60| r60_1(glval) = VariableAddress[x] : -# 60| r60_2(int) = Load : &:r60_1, m50_5 -# 60| r60_3(glval) = VariableAddress[y] : -# 60| r60_4(int) = Load : &:r60_3, m50_7 -# 60| r60_5(int) = BitOr : r60_2, r60_4 -# 60| r60_6(glval) = VariableAddress[z] : -# 60| m60_7(int) = Store : &:r60_6, r60_5 -# 61| r61_1(glval) = VariableAddress[x] : -# 61| r61_2(int) = Load : &:r61_1, m50_5 -# 61| r61_3(glval) = VariableAddress[y] : -# 61| r61_4(int) = Load : &:r61_3, m50_7 -# 61| r61_5(int) = BitXor : r61_2, r61_4 -# 61| r61_6(glval) = VariableAddress[z] : -# 61| m61_7(int) = Store : &:r61_6, r61_5 -# 63| r63_1(glval) = VariableAddress[x] : -# 63| r63_2(int) = Load : &:r63_1, m50_5 -# 63| r63_3(glval) = VariableAddress[y] : -# 63| r63_4(int) = Load : &:r63_3, m50_7 -# 63| r63_5(int) = ShiftLeft : r63_2, r63_4 -# 63| r63_6(glval) = VariableAddress[z] : -# 63| m63_7(int) = Store : &:r63_6, r63_5 -# 64| r64_1(glval) = VariableAddress[x] : -# 64| r64_2(int) = Load : &:r64_1, m50_5 -# 64| r64_3(glval) = VariableAddress[y] : -# 64| r64_4(int) = Load : &:r64_3, m50_7 -# 64| r64_5(int) = ShiftRight : r64_2, r64_4 -# 64| r64_6(glval) = VariableAddress[z] : -# 64| m64_7(int) = Store : &:r64_6, r64_5 -# 66| r66_1(glval) = VariableAddress[x] : -# 66| r66_2(int) = Load : &:r66_1, m50_5 -# 66| r66_3(glval) = VariableAddress[z] : -# 66| m66_4(int) = Store : &:r66_3, r66_2 -# 68| r68_1(glval) = VariableAddress[x] : -# 68| r68_2(int) = Load : &:r68_1, m50_5 -# 68| r68_3(glval) = VariableAddress[z] : -# 68| r68_4(int) = Load : &:r68_3, m66_4 -# 68| r68_5(int) = Add : r68_4, r68_2 -# 68| m68_6(int) = Store : &:r68_3, r68_5 -# 69| r69_1(glval) = VariableAddress[x] : -# 69| r69_2(int) = Load : &:r69_1, m50_5 -# 69| r69_3(glval) = VariableAddress[z] : -# 69| r69_4(int) = Load : &:r69_3, m68_6 -# 69| r69_5(int) = Sub : r69_4, r69_2 -# 69| m69_6(int) = Store : &:r69_3, r69_5 -# 70| r70_1(glval) = VariableAddress[x] : -# 70| r70_2(int) = Load : &:r70_1, m50_5 -# 70| r70_3(glval) = VariableAddress[z] : -# 70| r70_4(int) = Load : &:r70_3, m69_6 -# 70| r70_5(int) = Mul : r70_4, r70_2 -# 70| m70_6(int) = Store : &:r70_3, r70_5 -# 71| r71_1(glval) = VariableAddress[x] : -# 71| r71_2(int) = Load : &:r71_1, m50_5 -# 71| r71_3(glval) = VariableAddress[z] : -# 71| r71_4(int) = Load : &:r71_3, m70_6 -# 71| r71_5(int) = Div : r71_4, r71_2 -# 71| m71_6(int) = Store : &:r71_3, r71_5 -# 72| r72_1(glval) = VariableAddress[x] : -# 72| r72_2(int) = Load : &:r72_1, m50_5 -# 72| r72_3(glval) = VariableAddress[z] : -# 72| r72_4(int) = Load : &:r72_3, m71_6 -# 72| r72_5(int) = Rem : r72_4, r72_2 -# 72| m72_6(int) = Store : &:r72_3, r72_5 -# 74| r74_1(glval) = VariableAddress[x] : -# 74| r74_2(int) = Load : &:r74_1, m50_5 -# 74| r74_3(glval) = VariableAddress[z] : -# 74| r74_4(int) = Load : &:r74_3, m72_6 -# 74| r74_5(int) = BitAnd : r74_4, r74_2 -# 74| m74_6(int) = Store : &:r74_3, r74_5 -# 75| r75_1(glval) = VariableAddress[x] : -# 75| r75_2(int) = Load : &:r75_1, m50_5 -# 75| r75_3(glval) = VariableAddress[z] : -# 75| r75_4(int) = Load : &:r75_3, m74_6 -# 75| r75_5(int) = BitOr : r75_4, r75_2 -# 75| m75_6(int) = Store : &:r75_3, r75_5 -# 76| r76_1(glval) = VariableAddress[x] : -# 76| r76_2(int) = Load : &:r76_1, m50_5 -# 76| r76_3(glval) = VariableAddress[z] : -# 76| r76_4(int) = Load : &:r76_3, m75_6 -# 76| r76_5(int) = BitXor : r76_4, r76_2 -# 76| m76_6(int) = Store : &:r76_3, r76_5 -# 78| r78_1(glval) = VariableAddress[x] : -# 78| r78_2(int) = Load : &:r78_1, m50_5 -# 78| r78_3(glval) = VariableAddress[z] : -# 78| r78_4(int) = Load : &:r78_3, m76_6 -# 78| r78_5(int) = ShiftLeft : r78_4, r78_2 -# 78| m78_6(int) = Store : &:r78_3, r78_5 -# 79| r79_1(glval) = VariableAddress[x] : -# 79| r79_2(int) = Load : &:r79_1, m50_5 -# 79| r79_3(glval) = VariableAddress[z] : -# 79| r79_4(int) = Load : &:r79_3, m78_6 -# 79| r79_5(int) = ShiftRight : r79_4, r79_2 -# 79| m79_6(int) = Store : &:r79_3, r79_5 -# 81| r81_1(glval) = VariableAddress[x] : -# 81| r81_2(int) = Load : &:r81_1, m50_5 -# 81| r81_3(int) = CopyValue : r81_2 -# 81| r81_4(glval) = VariableAddress[z] : -# 81| m81_5(int) = Store : &:r81_4, r81_3 -# 82| r82_1(glval) = VariableAddress[x] : -# 82| r82_2(int) = Load : &:r82_1, m50_5 -# 82| r82_3(int) = Negate : r82_2 -# 82| r82_4(glval) = VariableAddress[z] : -# 82| m82_5(int) = Store : &:r82_4, r82_3 -# 83| r83_1(glval) = VariableAddress[x] : -# 83| r83_2(int) = Load : &:r83_1, m50_5 -# 83| r83_3(int) = BitComplement : r83_2 -# 83| r83_4(glval) = VariableAddress[z] : -# 83| m83_5(int) = Store : &:r83_4, r83_3 -# 84| r84_1(glval) = VariableAddress[x] : -# 84| r84_2(int) = Load : &:r84_1, m50_5 -# 84| r84_3(int) = Constant[0] : -# 84| r84_4(bool) = CompareNE : r84_2, r84_3 -# 84| r84_5(bool) = LogicalNot : r84_4 -# 84| r84_6(int) = Convert : r84_5 -# 84| r84_7(glval) = VariableAddress[z] : -# 84| m84_8(int) = Store : &:r84_7, r84_6 -# 85| v85_1(void) = NoOp : -# 50| v50_8(void) = ReturnVoid : -# 50| v50_9(void) = UnmodeledUse : mu* -# 50| v50_10(void) = AliasedUse : ~mu50_3 -# 50| v50_11(void) = ExitFunction : - -# 87| void IntegerCompare(int, int) -# 87| Block 0 -# 87| v87_1(void) = EnterFunction : -# 87| mu87_2(unknown) = AliasedDefinition : -# 87| mu87_3(unknown) = UnmodeledDefinition : -# 87| r87_4(glval) = VariableAddress[x] : -# 87| m87_5(int) = InitializeParameter[x] : &:r87_4 -# 87| r87_6(glval) = VariableAddress[y] : -# 87| m87_7(int) = InitializeParameter[y] : &:r87_6 -# 88| r88_1(glval) = VariableAddress[b] : -# 88| m88_2(bool) = Uninitialized[b] : &:r88_1 -# 90| r90_1(glval) = VariableAddress[x] : -# 90| r90_2(int) = Load : &:r90_1, m87_5 -# 90| r90_3(glval) = VariableAddress[y] : -# 90| r90_4(int) = Load : &:r90_3, m87_7 -# 90| r90_5(bool) = CompareEQ : r90_2, r90_4 -# 90| r90_6(glval) = VariableAddress[b] : -# 90| m90_7(bool) = Store : &:r90_6, r90_5 -# 91| r91_1(glval) = VariableAddress[x] : -# 91| r91_2(int) = Load : &:r91_1, m87_5 -# 91| r91_3(glval) = VariableAddress[y] : -# 91| r91_4(int) = Load : &:r91_3, m87_7 -# 91| r91_5(bool) = CompareNE : r91_2, r91_4 -# 91| r91_6(glval) = VariableAddress[b] : -# 91| m91_7(bool) = Store : &:r91_6, r91_5 -# 92| r92_1(glval) = VariableAddress[x] : -# 92| r92_2(int) = Load : &:r92_1, m87_5 -# 92| r92_3(glval) = VariableAddress[y] : -# 92| r92_4(int) = Load : &:r92_3, m87_7 -# 92| r92_5(bool) = CompareLT : r92_2, r92_4 -# 92| r92_6(glval) = VariableAddress[b] : -# 92| m92_7(bool) = Store : &:r92_6, r92_5 -# 93| r93_1(glval) = VariableAddress[x] : -# 93| r93_2(int) = Load : &:r93_1, m87_5 -# 93| r93_3(glval) = VariableAddress[y] : -# 93| r93_4(int) = Load : &:r93_3, m87_7 -# 93| r93_5(bool) = CompareGT : r93_2, r93_4 -# 93| r93_6(glval) = VariableAddress[b] : -# 93| m93_7(bool) = Store : &:r93_6, r93_5 -# 94| r94_1(glval) = VariableAddress[x] : -# 94| r94_2(int) = Load : &:r94_1, m87_5 -# 94| r94_3(glval) = VariableAddress[y] : -# 94| r94_4(int) = Load : &:r94_3, m87_7 -# 94| r94_5(bool) = CompareLE : r94_2, r94_4 -# 94| r94_6(glval) = VariableAddress[b] : -# 94| m94_7(bool) = Store : &:r94_6, r94_5 -# 95| r95_1(glval) = VariableAddress[x] : -# 95| r95_2(int) = Load : &:r95_1, m87_5 -# 95| r95_3(glval) = VariableAddress[y] : -# 95| r95_4(int) = Load : &:r95_3, m87_7 -# 95| r95_5(bool) = CompareGE : r95_2, r95_4 -# 95| r95_6(glval) = VariableAddress[b] : -# 95| m95_7(bool) = Store : &:r95_6, r95_5 -# 96| v96_1(void) = NoOp : -# 87| v87_8(void) = ReturnVoid : -# 87| v87_9(void) = UnmodeledUse : mu* -# 87| v87_10(void) = AliasedUse : ~mu87_3 -# 87| v87_11(void) = ExitFunction : - -# 98| void IntegerCrement(int) -# 98| Block 0 -# 98| v98_1(void) = EnterFunction : -# 98| mu98_2(unknown) = AliasedDefinition : -# 98| mu98_3(unknown) = UnmodeledDefinition : -# 98| r98_4(glval) = VariableAddress[x] : -# 98| m98_5(int) = InitializeParameter[x] : &:r98_4 -# 99| r99_1(glval) = VariableAddress[y] : -# 99| m99_2(int) = Uninitialized[y] : &:r99_1 -# 101| r101_1(glval) = VariableAddress[x] : -# 101| r101_2(int) = Load : &:r101_1, m98_5 -# 101| r101_3(int) = Constant[1] : -# 101| r101_4(int) = Add : r101_2, r101_3 -# 101| m101_5(int) = Store : &:r101_1, r101_4 -# 101| r101_6(glval) = VariableAddress[y] : -# 101| m101_7(int) = Store : &:r101_6, r101_4 -# 102| r102_1(glval) = VariableAddress[x] : -# 102| r102_2(int) = Load : &:r102_1, m101_5 -# 102| r102_3(int) = Constant[1] : -# 102| r102_4(int) = Sub : r102_2, r102_3 -# 102| m102_5(int) = Store : &:r102_1, r102_4 -# 102| r102_6(glval) = VariableAddress[y] : -# 102| m102_7(int) = Store : &:r102_6, r102_4 -# 103| r103_1(glval) = VariableAddress[x] : -# 103| r103_2(int) = Load : &:r103_1, m102_5 -# 103| r103_3(int) = Constant[1] : -# 103| r103_4(int) = Add : r103_2, r103_3 -# 103| m103_5(int) = Store : &:r103_1, r103_4 -# 103| r103_6(glval) = VariableAddress[y] : -# 103| m103_7(int) = Store : &:r103_6, r103_2 -# 104| r104_1(glval) = VariableAddress[x] : -# 104| r104_2(int) = Load : &:r104_1, m103_5 -# 104| r104_3(int) = Constant[1] : -# 104| r104_4(int) = Sub : r104_2, r104_3 -# 104| m104_5(int) = Store : &:r104_1, r104_4 -# 104| r104_6(glval) = VariableAddress[y] : -# 104| m104_7(int) = Store : &:r104_6, r104_2 -# 105| v105_1(void) = NoOp : -# 98| v98_6(void) = ReturnVoid : -# 98| v98_7(void) = UnmodeledUse : mu* -# 98| v98_8(void) = AliasedUse : ~mu98_3 -# 98| v98_9(void) = ExitFunction : - -# 107| void IntegerCrement_LValue(int) -# 107| Block 0 -# 107| v107_1(void) = EnterFunction : -# 107| mu107_2(unknown) = AliasedDefinition : -# 107| mu107_3(unknown) = UnmodeledDefinition : -# 107| r107_4(glval) = VariableAddress[x] : -# 107| m107_5(int) = InitializeParameter[x] : &:r107_4 -# 108| r108_1(glval) = VariableAddress[p] : -# 108| m108_2(int *) = Uninitialized[p] : &:r108_1 -# 110| r110_1(glval) = VariableAddress[x] : -# 110| r110_2(int) = Load : &:r110_1, m107_5 -# 110| r110_3(int) = Constant[1] : -# 110| r110_4(int) = Add : r110_2, r110_3 -# 110| m110_5(int) = Store : &:r110_1, r110_4 -# 110| r110_6(glval) = CopyValue : r110_1 -# 110| r110_7(int *) = CopyValue : r110_6 -# 110| r110_8(glval) = VariableAddress[p] : -# 110| m110_9(int *) = Store : &:r110_8, r110_7 -# 111| r111_1(glval) = VariableAddress[x] : -# 111| r111_2(int) = Load : &:r111_1, m110_5 -# 111| r111_3(int) = Constant[1] : -# 111| r111_4(int) = Sub : r111_2, r111_3 -# 111| m111_5(int) = Store : &:r111_1, r111_4 -# 111| r111_6(glval) = CopyValue : r111_1 -# 111| r111_7(int *) = CopyValue : r111_6 -# 111| r111_8(glval) = VariableAddress[p] : -# 111| m111_9(int *) = Store : &:r111_8, r111_7 -# 112| v112_1(void) = NoOp : -# 107| v107_6(void) = ReturnVoid : -# 107| v107_7(void) = UnmodeledUse : mu* -# 107| v107_8(void) = AliasedUse : ~mu107_3 -# 107| v107_9(void) = ExitFunction : - -# 114| void FloatOps(double, double) -# 114| Block 0 -# 114| v114_1(void) = EnterFunction : -# 114| mu114_2(unknown) = AliasedDefinition : -# 114| mu114_3(unknown) = UnmodeledDefinition : -# 114| r114_4(glval) = VariableAddress[x] : -# 114| m114_5(double) = InitializeParameter[x] : &:r114_4 -# 114| r114_6(glval) = VariableAddress[y] : -# 114| m114_7(double) = InitializeParameter[y] : &:r114_6 -# 115| r115_1(glval) = VariableAddress[z] : -# 115| m115_2(double) = Uninitialized[z] : &:r115_1 -# 117| r117_1(glval) = VariableAddress[x] : -# 117| r117_2(double) = Load : &:r117_1, m114_5 -# 117| r117_3(glval) = VariableAddress[y] : -# 117| r117_4(double) = Load : &:r117_3, m114_7 -# 117| r117_5(double) = Add : r117_2, r117_4 -# 117| r117_6(glval) = VariableAddress[z] : -# 117| m117_7(double) = Store : &:r117_6, r117_5 -# 118| r118_1(glval) = VariableAddress[x] : -# 118| r118_2(double) = Load : &:r118_1, m114_5 -# 118| r118_3(glval) = VariableAddress[y] : -# 118| r118_4(double) = Load : &:r118_3, m114_7 -# 118| r118_5(double) = Sub : r118_2, r118_4 -# 118| r118_6(glval) = VariableAddress[z] : -# 118| m118_7(double) = Store : &:r118_6, r118_5 -# 119| r119_1(glval) = VariableAddress[x] : -# 119| r119_2(double) = Load : &:r119_1, m114_5 -# 119| r119_3(glval) = VariableAddress[y] : -# 119| r119_4(double) = Load : &:r119_3, m114_7 -# 119| r119_5(double) = Mul : r119_2, r119_4 -# 119| r119_6(glval) = VariableAddress[z] : -# 119| m119_7(double) = Store : &:r119_6, r119_5 -# 120| r120_1(glval) = VariableAddress[x] : -# 120| r120_2(double) = Load : &:r120_1, m114_5 -# 120| r120_3(glval) = VariableAddress[y] : -# 120| r120_4(double) = Load : &:r120_3, m114_7 -# 120| r120_5(double) = Div : r120_2, r120_4 -# 120| r120_6(glval) = VariableAddress[z] : -# 120| m120_7(double) = Store : &:r120_6, r120_5 -# 122| r122_1(glval) = VariableAddress[x] : -# 122| r122_2(double) = Load : &:r122_1, m114_5 -# 122| r122_3(glval) = VariableAddress[z] : -# 122| m122_4(double) = Store : &:r122_3, r122_2 -# 124| r124_1(glval) = VariableAddress[x] : -# 124| r124_2(double) = Load : &:r124_1, m114_5 -# 124| r124_3(glval) = VariableAddress[z] : -# 124| r124_4(double) = Load : &:r124_3, m122_4 -# 124| r124_5(double) = Add : r124_4, r124_2 -# 124| m124_6(double) = Store : &:r124_3, r124_5 -# 125| r125_1(glval) = VariableAddress[x] : -# 125| r125_2(double) = Load : &:r125_1, m114_5 -# 125| r125_3(glval) = VariableAddress[z] : -# 125| r125_4(double) = Load : &:r125_3, m124_6 -# 125| r125_5(double) = Sub : r125_4, r125_2 -# 125| m125_6(double) = Store : &:r125_3, r125_5 -# 126| r126_1(glval) = VariableAddress[x] : -# 126| r126_2(double) = Load : &:r126_1, m114_5 -# 126| r126_3(glval) = VariableAddress[z] : -# 126| r126_4(double) = Load : &:r126_3, m125_6 -# 126| r126_5(double) = Mul : r126_4, r126_2 -# 126| m126_6(double) = Store : &:r126_3, r126_5 -# 127| r127_1(glval) = VariableAddress[x] : -# 127| r127_2(double) = Load : &:r127_1, m114_5 -# 127| r127_3(glval) = VariableAddress[z] : -# 127| r127_4(double) = Load : &:r127_3, m126_6 -# 127| r127_5(double) = Div : r127_4, r127_2 -# 127| m127_6(double) = Store : &:r127_3, r127_5 -# 129| r129_1(glval) = VariableAddress[x] : -# 129| r129_2(double) = Load : &:r129_1, m114_5 -# 129| r129_3(double) = CopyValue : r129_2 -# 129| r129_4(glval) = VariableAddress[z] : -# 129| m129_5(double) = Store : &:r129_4, r129_3 -# 130| r130_1(glval) = VariableAddress[x] : -# 130| r130_2(double) = Load : &:r130_1, m114_5 -# 130| r130_3(double) = Negate : r130_2 -# 130| r130_4(glval) = VariableAddress[z] : -# 130| m130_5(double) = Store : &:r130_4, r130_3 -# 131| v131_1(void) = NoOp : -# 114| v114_8(void) = ReturnVoid : -# 114| v114_9(void) = UnmodeledUse : mu* -# 114| v114_10(void) = AliasedUse : ~mu114_3 -# 114| v114_11(void) = ExitFunction : - -# 133| void FloatCompare(double, double) -# 133| Block 0 -# 133| v133_1(void) = EnterFunction : -# 133| mu133_2(unknown) = AliasedDefinition : -# 133| mu133_3(unknown) = UnmodeledDefinition : -# 133| r133_4(glval) = VariableAddress[x] : -# 133| m133_5(double) = InitializeParameter[x] : &:r133_4 -# 133| r133_6(glval) = VariableAddress[y] : -# 133| m133_7(double) = InitializeParameter[y] : &:r133_6 -# 134| r134_1(glval) = VariableAddress[b] : -# 134| m134_2(bool) = Uninitialized[b] : &:r134_1 -# 136| r136_1(glval) = VariableAddress[x] : -# 136| r136_2(double) = Load : &:r136_1, m133_5 -# 136| r136_3(glval) = VariableAddress[y] : -# 136| r136_4(double) = Load : &:r136_3, m133_7 -# 136| r136_5(bool) = CompareEQ : r136_2, r136_4 -# 136| r136_6(glval) = VariableAddress[b] : -# 136| m136_7(bool) = Store : &:r136_6, r136_5 -# 137| r137_1(glval) = VariableAddress[x] : -# 137| r137_2(double) = Load : &:r137_1, m133_5 -# 137| r137_3(glval) = VariableAddress[y] : -# 137| r137_4(double) = Load : &:r137_3, m133_7 -# 137| r137_5(bool) = CompareNE : r137_2, r137_4 -# 137| r137_6(glval) = VariableAddress[b] : -# 137| m137_7(bool) = Store : &:r137_6, r137_5 -# 138| r138_1(glval) = VariableAddress[x] : -# 138| r138_2(double) = Load : &:r138_1, m133_5 -# 138| r138_3(glval) = VariableAddress[y] : -# 138| r138_4(double) = Load : &:r138_3, m133_7 -# 138| r138_5(bool) = CompareLT : r138_2, r138_4 -# 138| r138_6(glval) = VariableAddress[b] : -# 138| m138_7(bool) = Store : &:r138_6, r138_5 -# 139| r139_1(glval) = VariableAddress[x] : -# 139| r139_2(double) = Load : &:r139_1, m133_5 -# 139| r139_3(glval) = VariableAddress[y] : -# 139| r139_4(double) = Load : &:r139_3, m133_7 -# 139| r139_5(bool) = CompareGT : r139_2, r139_4 -# 139| r139_6(glval) = VariableAddress[b] : -# 139| m139_7(bool) = Store : &:r139_6, r139_5 -# 140| r140_1(glval) = VariableAddress[x] : -# 140| r140_2(double) = Load : &:r140_1, m133_5 -# 140| r140_3(glval) = VariableAddress[y] : -# 140| r140_4(double) = Load : &:r140_3, m133_7 -# 140| r140_5(bool) = CompareLE : r140_2, r140_4 -# 140| r140_6(glval) = VariableAddress[b] : -# 140| m140_7(bool) = Store : &:r140_6, r140_5 -# 141| r141_1(glval) = VariableAddress[x] : -# 141| r141_2(double) = Load : &:r141_1, m133_5 -# 141| r141_3(glval) = VariableAddress[y] : -# 141| r141_4(double) = Load : &:r141_3, m133_7 -# 141| r141_5(bool) = CompareGE : r141_2, r141_4 -# 141| r141_6(glval) = VariableAddress[b] : -# 141| m141_7(bool) = Store : &:r141_6, r141_5 -# 142| v142_1(void) = NoOp : -# 133| v133_8(void) = ReturnVoid : -# 133| v133_9(void) = UnmodeledUse : mu* -# 133| v133_10(void) = AliasedUse : ~mu133_3 -# 133| v133_11(void) = ExitFunction : - -# 144| void FloatCrement(float) -# 144| Block 0 -# 144| v144_1(void) = EnterFunction : -# 144| mu144_2(unknown) = AliasedDefinition : -# 144| mu144_3(unknown) = UnmodeledDefinition : -# 144| r144_4(glval) = VariableAddress[x] : -# 144| m144_5(float) = InitializeParameter[x] : &:r144_4 -# 145| r145_1(glval) = VariableAddress[y] : -# 145| m145_2(float) = Uninitialized[y] : &:r145_1 -# 147| r147_1(glval) = VariableAddress[x] : -# 147| r147_2(float) = Load : &:r147_1, m144_5 -# 147| r147_3(float) = Constant[1.0] : -# 147| r147_4(float) = Add : r147_2, r147_3 -# 147| m147_5(float) = Store : &:r147_1, r147_4 -# 147| r147_6(glval) = VariableAddress[y] : -# 147| m147_7(float) = Store : &:r147_6, r147_4 -# 148| r148_1(glval) = VariableAddress[x] : -# 148| r148_2(float) = Load : &:r148_1, m147_5 -# 148| r148_3(float) = Constant[1.0] : -# 148| r148_4(float) = Sub : r148_2, r148_3 -# 148| m148_5(float) = Store : &:r148_1, r148_4 -# 148| r148_6(glval) = VariableAddress[y] : -# 148| m148_7(float) = Store : &:r148_6, r148_4 -# 149| r149_1(glval) = VariableAddress[x] : -# 149| r149_2(float) = Load : &:r149_1, m148_5 -# 149| r149_3(float) = Constant[1.0] : -# 149| r149_4(float) = Add : r149_2, r149_3 -# 149| m149_5(float) = Store : &:r149_1, r149_4 -# 149| r149_6(glval) = VariableAddress[y] : -# 149| m149_7(float) = Store : &:r149_6, r149_2 -# 150| r150_1(glval) = VariableAddress[x] : -# 150| r150_2(float) = Load : &:r150_1, m149_5 -# 150| r150_3(float) = Constant[1.0] : -# 150| r150_4(float) = Sub : r150_2, r150_3 -# 150| m150_5(float) = Store : &:r150_1, r150_4 -# 150| r150_6(glval) = VariableAddress[y] : -# 150| m150_7(float) = Store : &:r150_6, r150_2 -# 151| v151_1(void) = NoOp : -# 144| v144_6(void) = ReturnVoid : -# 144| v144_7(void) = UnmodeledUse : mu* -# 144| v144_8(void) = AliasedUse : ~mu144_3 -# 144| v144_9(void) = ExitFunction : - -# 153| void PointerOps(int*, int) -# 153| Block 0 -# 153| v153_1(void) = EnterFunction : -# 153| mu153_2(unknown) = AliasedDefinition : -# 153| mu153_3(unknown) = UnmodeledDefinition : -# 153| r153_4(glval) = VariableAddress[p] : -# 153| m153_5(int *) = InitializeParameter[p] : &:r153_4 -# 153| r153_6(int *) = Load : &:r153_4, m153_5 -# 153| mu153_7(unknown) = InitializeIndirection[p] : &:r153_6 -# 153| r153_8(glval) = VariableAddress[i] : -# 153| m153_9(int) = InitializeParameter[i] : &:r153_8 -# 154| r154_1(glval) = VariableAddress[q] : -# 154| m154_2(int *) = Uninitialized[q] : &:r154_1 -# 155| r155_1(glval) = VariableAddress[b] : -# 155| m155_2(bool) = Uninitialized[b] : &:r155_1 -# 157| r157_1(glval) = VariableAddress[p] : -# 157| r157_2(int *) = Load : &:r157_1, m153_5 -# 157| r157_3(glval) = VariableAddress[i] : -# 157| r157_4(int) = Load : &:r157_3, m153_9 -# 157| r157_5(int *) = PointerAdd[4] : r157_2, r157_4 -# 157| r157_6(glval) = VariableAddress[q] : -# 157| m157_7(int *) = Store : &:r157_6, r157_5 -# 158| r158_1(glval) = VariableAddress[i] : -# 158| r158_2(int) = Load : &:r158_1, m153_9 -# 158| r158_3(glval) = VariableAddress[p] : -# 158| r158_4(int *) = Load : &:r158_3, m153_5 -# 158| r158_5(int *) = PointerAdd[4] : r158_4, r158_2 -# 158| r158_6(glval) = VariableAddress[q] : -# 158| m158_7(int *) = Store : &:r158_6, r158_5 -# 159| r159_1(glval) = VariableAddress[p] : -# 159| r159_2(int *) = Load : &:r159_1, m153_5 -# 159| r159_3(glval) = VariableAddress[i] : -# 159| r159_4(int) = Load : &:r159_3, m153_9 -# 159| r159_5(int *) = PointerSub[4] : r159_2, r159_4 -# 159| r159_6(glval) = VariableAddress[q] : -# 159| m159_7(int *) = Store : &:r159_6, r159_5 -# 160| r160_1(glval) = VariableAddress[p] : -# 160| r160_2(int *) = Load : &:r160_1, m153_5 -# 160| r160_3(glval) = VariableAddress[q] : -# 160| r160_4(int *) = Load : &:r160_3, m159_7 -# 160| r160_5(long) = PointerDiff[4] : r160_2, r160_4 -# 160| r160_6(int) = Convert : r160_5 -# 160| r160_7(glval) = VariableAddress[i] : -# 160| m160_8(int) = Store : &:r160_7, r160_6 -# 162| r162_1(glval) = VariableAddress[p] : -# 162| r162_2(int *) = Load : &:r162_1, m153_5 -# 162| r162_3(glval) = VariableAddress[q] : -# 162| m162_4(int *) = Store : &:r162_3, r162_2 -# 164| r164_1(glval) = VariableAddress[i] : -# 164| r164_2(int) = Load : &:r164_1, m160_8 -# 164| r164_3(glval) = VariableAddress[q] : -# 164| r164_4(int *) = Load : &:r164_3, m162_4 -# 164| r164_5(int *) = PointerAdd[4] : r164_4, r164_2 -# 164| m164_6(int *) = Store : &:r164_3, r164_5 -# 165| r165_1(glval) = VariableAddress[i] : -# 165| r165_2(int) = Load : &:r165_1, m160_8 -# 165| r165_3(glval) = VariableAddress[q] : -# 165| r165_4(int *) = Load : &:r165_3, m164_6 -# 165| r165_5(int *) = PointerSub[4] : r165_4, r165_2 -# 165| m165_6(int *) = Store : &:r165_3, r165_5 -# 167| r167_1(glval) = VariableAddress[p] : -# 167| r167_2(int *) = Load : &:r167_1, m153_5 -# 167| r167_3(int *) = Constant[0] : -# 167| r167_4(bool) = CompareNE : r167_2, r167_3 -# 167| r167_5(glval) = VariableAddress[b] : -# 167| m167_6(bool) = Store : &:r167_5, r167_4 -# 168| r168_1(glval) = VariableAddress[p] : -# 168| r168_2(int *) = Load : &:r168_1, m153_5 -# 168| r168_3(int *) = Constant[0] : -# 168| r168_4(bool) = CompareNE : r168_2, r168_3 -# 168| r168_5(bool) = LogicalNot : r168_4 -# 168| r168_6(glval) = VariableAddress[b] : -# 168| m168_7(bool) = Store : &:r168_6, r168_5 -# 169| v169_1(void) = NoOp : -# 153| v153_10(void) = ReturnIndirection : &:r153_6, ~mu153_3 -# 153| v153_11(void) = ReturnVoid : -# 153| v153_12(void) = UnmodeledUse : mu* -# 153| v153_13(void) = AliasedUse : ~mu153_3 -# 153| v153_14(void) = ExitFunction : - -# 171| void ArrayAccess(int*, int) -# 171| Block 0 -# 171| v171_1(void) = EnterFunction : -# 171| mu171_2(unknown) = AliasedDefinition : -# 171| mu171_3(unknown) = UnmodeledDefinition : -# 171| r171_4(glval) = VariableAddress[p] : -# 171| m171_5(int *) = InitializeParameter[p] : &:r171_4 -# 171| r171_6(int *) = Load : &:r171_4, m171_5 -# 171| mu171_7(unknown) = InitializeIndirection[p] : &:r171_6 -# 171| r171_8(glval) = VariableAddress[i] : -# 171| m171_9(int) = InitializeParameter[i] : &:r171_8 -# 172| r172_1(glval) = VariableAddress[x] : -# 172| m172_2(int) = Uninitialized[x] : &:r172_1 -# 174| r174_1(glval) = VariableAddress[p] : -# 174| r174_2(int *) = Load : &:r174_1, m171_5 -# 174| r174_3(glval) = VariableAddress[i] : -# 174| r174_4(int) = Load : &:r174_3, m171_9 -# 174| r174_5(glval) = PointerAdd[4] : r174_2, r174_4 -# 174| r174_6(int) = Load : &:r174_5, ~mu171_3 -# 174| r174_7(glval) = VariableAddress[x] : -# 174| m174_8(int) = Store : &:r174_7, r174_6 -# 175| r175_1(glval) = VariableAddress[p] : -# 175| r175_2(int *) = Load : &:r175_1, m171_5 -# 175| r175_3(glval) = VariableAddress[i] : -# 175| r175_4(int) = Load : &:r175_3, m171_9 -# 175| r175_5(glval) = PointerAdd[4] : r175_2, r175_4 -# 175| r175_6(int) = Load : &:r175_5, ~mu171_3 -# 175| r175_7(glval) = VariableAddress[x] : -# 175| m175_8(int) = Store : &:r175_7, r175_6 -# 177| r177_1(glval) = VariableAddress[x] : -# 177| r177_2(int) = Load : &:r177_1, m175_8 -# 177| r177_3(glval) = VariableAddress[p] : -# 177| r177_4(int *) = Load : &:r177_3, m171_5 -# 177| r177_5(glval) = VariableAddress[i] : -# 177| r177_6(int) = Load : &:r177_5, m171_9 -# 177| r177_7(glval) = PointerAdd[4] : r177_4, r177_6 -# 177| mu177_8(int) = Store : &:r177_7, r177_2 -# 178| r178_1(glval) = VariableAddress[x] : -# 178| r178_2(int) = Load : &:r178_1, m175_8 -# 178| r178_3(glval) = VariableAddress[p] : -# 178| r178_4(int *) = Load : &:r178_3, m171_5 -# 178| r178_5(glval) = VariableAddress[i] : -# 178| r178_6(int) = Load : &:r178_5, m171_9 -# 178| r178_7(glval) = PointerAdd[4] : r178_4, r178_6 -# 178| mu178_8(int) = Store : &:r178_7, r178_2 -# 180| r180_1(glval) = VariableAddress[a] : -# 180| mu180_2(int[10]) = Uninitialized[a] : &:r180_1 -# 181| r181_1(glval) = VariableAddress[a] : -# 181| r181_2(int *) = Convert : r181_1 -# 181| r181_3(glval) = VariableAddress[i] : -# 181| r181_4(int) = Load : &:r181_3, m171_9 -# 181| r181_5(glval) = PointerAdd[4] : r181_2, r181_4 -# 181| r181_6(int) = Load : &:r181_5, ~mu171_3 -# 181| r181_7(glval) = VariableAddress[x] : -# 181| m181_8(int) = Store : &:r181_7, r181_6 -# 182| r182_1(glval) = VariableAddress[a] : -# 182| r182_2(int *) = Convert : r182_1 -# 182| r182_3(glval) = VariableAddress[i] : -# 182| r182_4(int) = Load : &:r182_3, m171_9 -# 182| r182_5(glval) = PointerAdd[4] : r182_2, r182_4 -# 182| r182_6(int) = Load : &:r182_5, ~mu171_3 -# 182| r182_7(glval) = VariableAddress[x] : -# 182| m182_8(int) = Store : &:r182_7, r182_6 -# 183| r183_1(glval) = VariableAddress[x] : -# 183| r183_2(int) = Load : &:r183_1, m182_8 -# 183| r183_3(glval) = VariableAddress[a] : -# 183| r183_4(int *) = Convert : r183_3 -# 183| r183_5(glval) = VariableAddress[i] : -# 183| r183_6(int) = Load : &:r183_5, m171_9 -# 183| r183_7(glval) = PointerAdd[4] : r183_4, r183_6 -# 183| mu183_8(int) = Store : &:r183_7, r183_2 -# 184| r184_1(glval) = VariableAddress[x] : -# 184| r184_2(int) = Load : &:r184_1, m182_8 -# 184| r184_3(glval) = VariableAddress[a] : -# 184| r184_4(int *) = Convert : r184_3 -# 184| r184_5(glval) = VariableAddress[i] : -# 184| r184_6(int) = Load : &:r184_5, m171_9 -# 184| r184_7(glval) = PointerAdd[4] : r184_4, r184_6 -# 184| mu184_8(int) = Store : &:r184_7, r184_2 -# 185| v185_1(void) = NoOp : -# 171| v171_10(void) = ReturnIndirection : &:r171_6, ~mu171_3 -# 171| v171_11(void) = ReturnVoid : -# 171| v171_12(void) = UnmodeledUse : mu* -# 171| v171_13(void) = AliasedUse : ~mu171_3 -# 171| v171_14(void) = ExitFunction : - -# 187| void StringLiteral(int) -# 187| Block 0 -# 187| v187_1(void) = EnterFunction : -# 187| mu187_2(unknown) = AliasedDefinition : -# 187| mu187_3(unknown) = UnmodeledDefinition : -# 187| r187_4(glval) = VariableAddress[i] : -# 187| m187_5(int) = InitializeParameter[i] : &:r187_4 -# 188| r188_1(glval) = VariableAddress[c] : -# 188| r188_2(glval) = StringConstant["Foo"] : -# 188| r188_3(char *) = Convert : r188_2 -# 188| r188_4(glval) = VariableAddress[i] : -# 188| r188_5(int) = Load : &:r188_4, m187_5 -# 188| r188_6(glval) = PointerAdd[1] : r188_3, r188_5 -# 188| r188_7(char) = Load : &:r188_6, ~mu187_3 -# 188| m188_8(char) = Store : &:r188_1, r188_7 -# 189| r189_1(glval) = VariableAddress[pwc] : -# 189| r189_2(glval) = StringConstant[L"Bar"] : -# 189| r189_3(wchar_t *) = Convert : r189_2 -# 189| r189_4(wchar_t *) = Convert : r189_3 -# 189| m189_5(wchar_t *) = Store : &:r189_1, r189_4 -# 190| r190_1(glval) = VariableAddress[wc] : -# 190| r190_2(glval) = VariableAddress[pwc] : -# 190| r190_3(wchar_t *) = Load : &:r190_2, m189_5 -# 190| r190_4(glval) = VariableAddress[i] : -# 190| r190_5(int) = Load : &:r190_4, m187_5 -# 190| r190_6(glval) = PointerAdd[4] : r190_3, r190_5 -# 190| r190_7(wchar_t) = Load : &:r190_6, ~mu187_3 -# 190| m190_8(wchar_t) = Store : &:r190_1, r190_7 -# 191| v191_1(void) = NoOp : -# 187| v187_6(void) = ReturnVoid : -# 187| v187_7(void) = UnmodeledUse : mu* -# 187| v187_8(void) = AliasedUse : ~mu187_3 -# 187| v187_9(void) = ExitFunction : - -# 193| void PointerCompare(int*, int*) -# 193| Block 0 -# 193| v193_1(void) = EnterFunction : -# 193| mu193_2(unknown) = AliasedDefinition : -# 193| mu193_3(unknown) = UnmodeledDefinition : -# 193| r193_4(glval) = VariableAddress[p] : -# 193| m193_5(int *) = InitializeParameter[p] : &:r193_4 -# 193| r193_6(int *) = Load : &:r193_4, m193_5 -# 193| mu193_7(unknown) = InitializeIndirection[p] : &:r193_6 -# 193| r193_8(glval) = VariableAddress[q] : -# 193| m193_9(int *) = InitializeParameter[q] : &:r193_8 -# 193| r193_10(int *) = Load : &:r193_8, m193_9 -# 193| mu193_11(unknown) = InitializeIndirection[q] : &:r193_10 -# 194| r194_1(glval) = VariableAddress[b] : -# 194| m194_2(bool) = Uninitialized[b] : &:r194_1 -# 196| r196_1(glval) = VariableAddress[p] : -# 196| r196_2(int *) = Load : &:r196_1, m193_5 -# 196| r196_3(glval) = VariableAddress[q] : -# 196| r196_4(int *) = Load : &:r196_3, m193_9 -# 196| r196_5(bool) = CompareEQ : r196_2, r196_4 -# 196| r196_6(glval) = VariableAddress[b] : -# 196| m196_7(bool) = Store : &:r196_6, r196_5 -# 197| r197_1(glval) = VariableAddress[p] : -# 197| r197_2(int *) = Load : &:r197_1, m193_5 -# 197| r197_3(glval) = VariableAddress[q] : -# 197| r197_4(int *) = Load : &:r197_3, m193_9 -# 197| r197_5(bool) = CompareNE : r197_2, r197_4 -# 197| r197_6(glval) = VariableAddress[b] : -# 197| m197_7(bool) = Store : &:r197_6, r197_5 -# 198| r198_1(glval) = VariableAddress[p] : -# 198| r198_2(int *) = Load : &:r198_1, m193_5 -# 198| r198_3(glval) = VariableAddress[q] : -# 198| r198_4(int *) = Load : &:r198_3, m193_9 -# 198| r198_5(bool) = CompareLT : r198_2, r198_4 -# 198| r198_6(glval) = VariableAddress[b] : -# 198| m198_7(bool) = Store : &:r198_6, r198_5 -# 199| r199_1(glval) = VariableAddress[p] : -# 199| r199_2(int *) = Load : &:r199_1, m193_5 -# 199| r199_3(glval) = VariableAddress[q] : -# 199| r199_4(int *) = Load : &:r199_3, m193_9 -# 199| r199_5(bool) = CompareGT : r199_2, r199_4 -# 199| r199_6(glval) = VariableAddress[b] : -# 199| m199_7(bool) = Store : &:r199_6, r199_5 -# 200| r200_1(glval) = VariableAddress[p] : -# 200| r200_2(int *) = Load : &:r200_1, m193_5 -# 200| r200_3(glval) = VariableAddress[q] : -# 200| r200_4(int *) = Load : &:r200_3, m193_9 -# 200| r200_5(bool) = CompareLE : r200_2, r200_4 -# 200| r200_6(glval) = VariableAddress[b] : -# 200| m200_7(bool) = Store : &:r200_6, r200_5 -# 201| r201_1(glval) = VariableAddress[p] : -# 201| r201_2(int *) = Load : &:r201_1, m193_5 -# 201| r201_3(glval) = VariableAddress[q] : -# 201| r201_4(int *) = Load : &:r201_3, m193_9 -# 201| r201_5(bool) = CompareGE : r201_2, r201_4 -# 201| r201_6(glval) = VariableAddress[b] : -# 201| m201_7(bool) = Store : &:r201_6, r201_5 -# 202| v202_1(void) = NoOp : -# 193| v193_12(void) = ReturnIndirection : &:r193_6, ~mu193_3 -# 193| v193_13(void) = ReturnIndirection : &:r193_10, ~mu193_3 -# 193| v193_14(void) = ReturnVoid : -# 193| v193_15(void) = UnmodeledUse : mu* -# 193| v193_16(void) = AliasedUse : ~mu193_3 -# 193| v193_17(void) = ExitFunction : - -# 204| void PointerCrement(int*) -# 204| Block 0 -# 204| v204_1(void) = EnterFunction : -# 204| mu204_2(unknown) = AliasedDefinition : -# 204| mu204_3(unknown) = UnmodeledDefinition : -# 204| r204_4(glval) = VariableAddress[p] : -# 204| m204_5(int *) = InitializeParameter[p] : &:r204_4 -# 204| r204_6(int *) = Load : &:r204_4, m204_5 -# 204| mu204_7(unknown) = InitializeIndirection[p] : &:r204_6 -# 205| r205_1(glval) = VariableAddress[q] : -# 205| m205_2(int *) = Uninitialized[q] : &:r205_1 -# 207| r207_1(glval) = VariableAddress[p] : -# 207| r207_2(int *) = Load : &:r207_1, m204_5 -# 207| r207_3(int) = Constant[1] : -# 207| r207_4(int *) = PointerAdd[4] : r207_2, r207_3 -# 207| m207_5(int *) = Store : &:r207_1, r207_4 -# 207| r207_6(glval) = VariableAddress[q] : -# 207| m207_7(int *) = Store : &:r207_6, r207_4 -# 208| r208_1(glval) = VariableAddress[p] : -# 208| r208_2(int *) = Load : &:r208_1, m207_5 -# 208| r208_3(int) = Constant[1] : -# 208| r208_4(int *) = PointerSub[4] : r208_2, r208_3 -# 208| m208_5(int *) = Store : &:r208_1, r208_4 -# 208| r208_6(glval) = VariableAddress[q] : -# 208| m208_7(int *) = Store : &:r208_6, r208_4 -# 209| r209_1(glval) = VariableAddress[p] : -# 209| r209_2(int *) = Load : &:r209_1, m208_5 -# 209| r209_3(int) = Constant[1] : -# 209| r209_4(int *) = PointerAdd[4] : r209_2, r209_3 -# 209| m209_5(int *) = Store : &:r209_1, r209_4 -# 209| r209_6(glval) = VariableAddress[q] : -# 209| m209_7(int *) = Store : &:r209_6, r209_2 -# 210| r210_1(glval) = VariableAddress[p] : -# 210| r210_2(int *) = Load : &:r210_1, m209_5 -# 210| r210_3(int) = Constant[1] : -# 210| r210_4(int *) = PointerSub[4] : r210_2, r210_3 -# 210| m210_5(int *) = Store : &:r210_1, r210_4 -# 210| r210_6(glval) = VariableAddress[q] : -# 210| m210_7(int *) = Store : &:r210_6, r210_2 -# 211| v211_1(void) = NoOp : -# 204| v204_8(void) = ReturnIndirection : &:r204_6, ~mu204_3 -# 204| v204_9(void) = ReturnVoid : -# 204| v204_10(void) = UnmodeledUse : mu* -# 204| v204_11(void) = AliasedUse : ~mu204_3 -# 204| v204_12(void) = ExitFunction : - -# 213| void CompoundAssignment() -# 213| Block 0 -# 213| v213_1(void) = EnterFunction : -# 213| mu213_2(unknown) = AliasedDefinition : -# 213| mu213_3(unknown) = UnmodeledDefinition : -# 215| r215_1(glval) = VariableAddress[x] : -# 215| r215_2(int) = Constant[5] : -# 215| m215_3(int) = Store : &:r215_1, r215_2 -# 216| r216_1(int) = Constant[7] : -# 216| r216_2(glval) = VariableAddress[x] : -# 216| r216_3(int) = Load : &:r216_2, m215_3 -# 216| r216_4(int) = Add : r216_3, r216_1 -# 216| m216_5(int) = Store : &:r216_2, r216_4 -# 219| r219_1(glval) = VariableAddress[y] : -# 219| r219_2(short) = Constant[5] : -# 219| m219_3(short) = Store : &:r219_1, r219_2 -# 220| r220_1(glval) = VariableAddress[x] : -# 220| r220_2(int) = Load : &:r220_1, m216_5 -# 220| r220_3(glval) = VariableAddress[y] : -# 220| r220_4(short) = Load : &:r220_3, m219_3 -# 220| r220_5(int) = Convert : r220_4 -# 220| r220_6(int) = Add : r220_5, r220_2 -# 220| r220_7(short) = Convert : r220_6 -# 220| m220_8(short) = Store : &:r220_3, r220_7 -# 223| r223_1(int) = Constant[1] : -# 223| r223_2(glval) = VariableAddress[y] : -# 223| r223_3(short) = Load : &:r223_2, m220_8 -# 223| r223_4(short) = ShiftLeft : r223_3, r223_1 -# 223| m223_5(short) = Store : &:r223_2, r223_4 -# 226| r226_1(glval) = VariableAddress[z] : -# 226| r226_2(long) = Constant[7] : -# 226| m226_3(long) = Store : &:r226_1, r226_2 -# 227| r227_1(float) = Constant[2.0] : -# 227| r227_2(glval) = VariableAddress[z] : -# 227| r227_3(long) = Load : &:r227_2, m226_3 -# 227| r227_4(float) = Convert : r227_3 -# 227| r227_5(float) = Add : r227_4, r227_1 -# 227| r227_6(long) = Convert : r227_5 -# 227| m227_7(long) = Store : &:r227_2, r227_6 -# 228| v228_1(void) = NoOp : -# 213| v213_4(void) = ReturnVoid : -# 213| v213_5(void) = UnmodeledUse : mu* -# 213| v213_6(void) = AliasedUse : ~mu213_3 -# 213| v213_7(void) = ExitFunction : - -# 230| void UninitializedVariables() -# 230| Block 0 -# 230| v230_1(void) = EnterFunction : -# 230| mu230_2(unknown) = AliasedDefinition : -# 230| mu230_3(unknown) = UnmodeledDefinition : -# 231| r231_1(glval) = VariableAddress[x] : -# 231| m231_2(int) = Uninitialized[x] : &:r231_1 -# 232| r232_1(glval) = VariableAddress[y] : -# 232| r232_2(glval) = VariableAddress[x] : -# 232| r232_3(int) = Load : &:r232_2, m231_2 -# 232| m232_4(int) = Store : &:r232_1, r232_3 -# 233| v233_1(void) = NoOp : -# 230| v230_4(void) = ReturnVoid : -# 230| v230_5(void) = UnmodeledUse : mu* -# 230| v230_6(void) = AliasedUse : ~mu230_3 -# 230| v230_7(void) = ExitFunction : - -# 235| int Parameters(int, int) -# 235| Block 0 -# 235| v235_1(void) = EnterFunction : -# 235| mu235_2(unknown) = AliasedDefinition : -# 235| mu235_3(unknown) = UnmodeledDefinition : -# 235| r235_4(glval) = VariableAddress[x] : -# 235| m235_5(int) = InitializeParameter[x] : &:r235_4 -# 235| r235_6(glval) = VariableAddress[y] : -# 235| m235_7(int) = InitializeParameter[y] : &:r235_6 -# 236| r236_1(glval) = VariableAddress[#return] : -# 236| r236_2(glval) = VariableAddress[x] : -# 236| r236_3(int) = Load : &:r236_2, m235_5 -# 236| r236_4(glval) = VariableAddress[y] : -# 236| r236_5(int) = Load : &:r236_4, m235_7 -# 236| r236_6(int) = Rem : r236_3, r236_5 -# 236| m236_7(int) = Store : &:r236_1, r236_6 -# 235| r235_8(glval) = VariableAddress[#return] : -# 235| v235_9(void) = ReturnValue : &:r235_8, m236_7 -# 235| v235_10(void) = UnmodeledUse : mu* -# 235| v235_11(void) = AliasedUse : ~mu235_3 -# 235| v235_12(void) = ExitFunction : - -# 239| void IfStatements(bool, int, int) -# 239| Block 0 -# 239| v239_1(void) = EnterFunction : -# 239| mu239_2(unknown) = AliasedDefinition : -# 239| mu239_3(unknown) = UnmodeledDefinition : -# 239| r239_4(glval) = VariableAddress[b] : -# 239| m239_5(bool) = InitializeParameter[b] : &:r239_4 -# 239| r239_6(glval) = VariableAddress[x] : -# 239| m239_7(int) = InitializeParameter[x] : &:r239_6 -# 239| r239_8(glval) = VariableAddress[y] : -# 239| m239_9(int) = InitializeParameter[y] : &:r239_8 -# 240| r240_1(glval) = VariableAddress[b] : -# 240| r240_2(bool) = Load : &:r240_1, m239_5 -# 240| v240_3(void) = ConditionalBranch : r240_2 -#-----| False -> Block 1 -#-----| True -> Block 7 - -# 243| Block 1 -# 243| r243_1(glval) = VariableAddress[b] : -# 243| r243_2(bool) = Load : &:r243_1, m239_5 -# 243| v243_3(void) = ConditionalBranch : r243_2 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 244| Block 2 -# 244| r244_1(glval) = VariableAddress[y] : -# 244| r244_2(int) = Load : &:r244_1, m239_9 -# 244| r244_3(glval) = VariableAddress[x] : -# 244| m244_4(int) = Store : &:r244_3, r244_2 -#-----| Goto -> Block 3 - -# 247| Block 3 -# 247| m247_1(int) = Phi : from 1:m239_7, from 2:m244_4 -# 247| r247_2(glval) = VariableAddress[x] : -# 247| r247_3(int) = Load : &:r247_2, m247_1 -# 247| r247_4(int) = Constant[7] : -# 247| r247_5(bool) = CompareLT : r247_3, r247_4 -# 247| v247_6(void) = ConditionalBranch : r247_5 -#-----| False -> Block 5 -#-----| True -> Block 4 - -# 248| Block 4 -# 248| r248_1(int) = Constant[2] : -# 248| r248_2(glval) = VariableAddress[x] : -# 248| m248_3(int) = Store : &:r248_2, r248_1 -#-----| Goto -> Block 6 - -# 250| Block 5 -# 250| r250_1(int) = Constant[7] : -# 250| r250_2(glval) = VariableAddress[x] : -# 250| m250_3(int) = Store : &:r250_2, r250_1 -#-----| Goto -> Block 6 - -# 251| Block 6 -# 251| v251_1(void) = NoOp : -# 239| v239_10(void) = ReturnVoid : -# 239| v239_11(void) = UnmodeledUse : mu* -# 239| v239_12(void) = AliasedUse : ~mu239_3 -# 239| v239_13(void) = ExitFunction : - -# 240| Block 7 -# 240| v240_4(void) = NoOp : -#-----| Goto -> Block 1 - -# 253| void WhileStatements(int) -# 253| Block 0 -# 253| v253_1(void) = EnterFunction : -# 253| mu253_2(unknown) = AliasedDefinition : -# 253| mu253_3(unknown) = UnmodeledDefinition : -# 253| r253_4(glval) = VariableAddress[n] : -# 253| m253_5(int) = InitializeParameter[n] : &:r253_4 -#-----| Goto -> Block 3 - -# 255| Block 1 -# 255| r255_1(int) = Constant[1] : -# 255| r255_2(glval) = VariableAddress[n] : -# 255| r255_3(int) = Load : &:r255_2, m254_1 -# 255| r255_4(int) = Sub : r255_3, r255_1 -# 255| m255_5(int) = Store : &:r255_2, r255_4 -#-----| Goto (back edge) -> Block 3 - -# 257| Block 2 -# 257| v257_1(void) = NoOp : -# 253| v253_6(void) = ReturnVoid : -# 253| v253_7(void) = UnmodeledUse : mu* -# 253| v253_8(void) = AliasedUse : ~mu253_3 -# 253| v253_9(void) = ExitFunction : - -# 254| Block 3 -# 254| m254_1(int) = Phi : from 0:m253_5, from 1:m255_5 -# 254| r254_2(glval) = VariableAddress[n] : -# 254| r254_3(int) = Load : &:r254_2, m254_1 -# 254| r254_4(int) = Constant[0] : -# 254| r254_5(bool) = CompareGT : r254_3, r254_4 -# 254| v254_6(void) = ConditionalBranch : r254_5 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 259| void DoStatements(int) -# 259| Block 0 -# 259| v259_1(void) = EnterFunction : -# 259| mu259_2(unknown) = AliasedDefinition : -# 259| mu259_3(unknown) = UnmodeledDefinition : -# 259| r259_4(glval) = VariableAddress[n] : -# 259| m259_5(int) = InitializeParameter[n] : &:r259_4 -#-----| Goto -> Block 1 - -# 261| Block 1 -# 261| m261_1(int) = Phi : from 0:m259_5, from 1:m261_6 -# 261| r261_2(int) = Constant[1] : -# 261| r261_3(glval) = VariableAddress[n] : -# 261| r261_4(int) = Load : &:r261_3, m261_1 -# 261| r261_5(int) = Sub : r261_4, r261_2 -# 261| m261_6(int) = Store : &:r261_3, r261_5 -# 262| r262_1(glval) = VariableAddress[n] : -# 262| r262_2(int) = Load : &:r262_1, m261_6 -# 262| r262_3(int) = Constant[0] : -# 262| r262_4(bool) = CompareGT : r262_2, r262_3 -# 262| v262_5(void) = ConditionalBranch : r262_4 -#-----| False -> Block 2 -#-----| True (back edge) -> Block 1 - -# 263| Block 2 -# 263| v263_1(void) = NoOp : -# 259| v259_6(void) = ReturnVoid : -# 259| v259_7(void) = UnmodeledUse : mu* -# 259| v259_8(void) = AliasedUse : ~mu259_3 -# 259| v259_9(void) = ExitFunction : - -# 265| void For_Empty() -# 265| Block 0 -# 265| v265_1(void) = EnterFunction : -# 265| mu265_2(unknown) = AliasedDefinition : -# 265| mu265_3(unknown) = UnmodeledDefinition : -# 266| r266_1(glval) = VariableAddress[j] : -# 266| m266_2(int) = Uninitialized[j] : &:r266_1 -#-----| Goto -> Block 1 - -# 268| Block 1 -# 268| v268_1(void) = NoOp : -#-----| Goto (back edge) -> Block 1 - -# 272| void For_Init() -# 272| Block 0 -# 272| v272_1(void) = EnterFunction : -# 272| mu272_2(unknown) = AliasedDefinition : -# 272| mu272_3(unknown) = UnmodeledDefinition : -# 273| r273_1(glval) = VariableAddress[i] : -# 273| r273_2(int) = Constant[0] : -# 273| m273_3(int) = Store : &:r273_1, r273_2 -#-----| Goto -> Block 1 - -# 274| Block 1 -# 274| v274_1(void) = NoOp : -#-----| Goto (back edge) -> Block 1 - -# 278| void For_Condition() -# 278| Block 0 -# 278| v278_1(void) = EnterFunction : -# 278| mu278_2(unknown) = AliasedDefinition : -# 278| mu278_3(unknown) = UnmodeledDefinition : -# 279| r279_1(glval) = VariableAddress[i] : -# 279| r279_2(int) = Constant[0] : -# 279| m279_3(int) = Store : &:r279_1, r279_2 -#-----| Goto -> Block 1 - -# 280| Block 1 -# 280| r280_1(glval) = VariableAddress[i] : -# 280| r280_2(int) = Load : &:r280_1, m279_3 -# 280| r280_3(int) = Constant[10] : -# 280| r280_4(bool) = CompareLT : r280_2, r280_3 -# 280| v280_5(void) = ConditionalBranch : r280_4 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 281| Block 2 -# 281| v281_1(void) = NoOp : -#-----| Goto (back edge) -> Block 1 - -# 283| Block 3 -# 283| v283_1(void) = NoOp : -# 278| v278_4(void) = ReturnVoid : -# 278| v278_5(void) = UnmodeledUse : mu* -# 278| v278_6(void) = AliasedUse : ~mu278_3 -# 278| v278_7(void) = ExitFunction : - -# 285| void For_Update() -# 285| Block 0 -# 285| v285_1(void) = EnterFunction : -# 285| mu285_2(unknown) = AliasedDefinition : -# 285| mu285_3(unknown) = UnmodeledDefinition : -# 286| r286_1(glval) = VariableAddress[i] : -# 286| r286_2(int) = Constant[0] : -# 286| m286_3(int) = Store : &:r286_1, r286_2 -#-----| Goto -> Block 1 - -# 288| Block 1 -# 288| m288_1(int) = Phi : from 0:m286_3, from 1:m287_5 -# 288| v288_2(void) = NoOp : -# 287| r287_1(int) = Constant[1] : -# 287| r287_2(glval) = VariableAddress[i] : -# 287| r287_3(int) = Load : &:r287_2, m288_1 -# 287| r287_4(int) = Add : r287_3, r287_1 -# 287| m287_5(int) = Store : &:r287_2, r287_4 -#-----| Goto (back edge) -> Block 1 - -# 292| void For_InitCondition() -# 292| Block 0 -# 292| v292_1(void) = EnterFunction : -# 292| mu292_2(unknown) = AliasedDefinition : -# 292| mu292_3(unknown) = UnmodeledDefinition : -# 293| r293_1(glval) = VariableAddress[i] : -# 293| r293_2(int) = Constant[0] : -# 293| m293_3(int) = Store : &:r293_1, r293_2 -#-----| Goto -> Block 1 - -# 293| Block 1 -# 293| r293_4(glval) = VariableAddress[i] : -# 293| r293_5(int) = Load : &:r293_4, m293_3 -# 293| r293_6(int) = Constant[10] : -# 293| r293_7(bool) = CompareLT : r293_5, r293_6 -# 293| v293_8(void) = ConditionalBranch : r293_7 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 294| Block 2 -# 294| v294_1(void) = NoOp : -#-----| Goto (back edge) -> Block 1 - -# 296| Block 3 -# 296| v296_1(void) = NoOp : -# 292| v292_4(void) = ReturnVoid : -# 292| v292_5(void) = UnmodeledUse : mu* -# 292| v292_6(void) = AliasedUse : ~mu292_3 -# 292| v292_7(void) = ExitFunction : - -# 298| void For_InitUpdate() -# 298| Block 0 -# 298| v298_1(void) = EnterFunction : -# 298| mu298_2(unknown) = AliasedDefinition : -# 298| mu298_3(unknown) = UnmodeledDefinition : -# 299| r299_1(glval) = VariableAddress[i] : -# 299| r299_2(int) = Constant[0] : -# 299| m299_3(int) = Store : &:r299_1, r299_2 -#-----| Goto -> Block 1 - -# 300| Block 1 -# 300| m300_1(int) = Phi : from 0:m299_3, from 1:m299_8 -# 300| v300_2(void) = NoOp : -# 299| r299_4(int) = Constant[1] : -# 299| r299_5(glval) = VariableAddress[i] : -# 299| r299_6(int) = Load : &:r299_5, m300_1 -# 299| r299_7(int) = Add : r299_6, r299_4 -# 299| m299_8(int) = Store : &:r299_5, r299_7 -#-----| Goto (back edge) -> Block 1 - -# 304| void For_ConditionUpdate() -# 304| Block 0 -# 304| v304_1(void) = EnterFunction : -# 304| mu304_2(unknown) = AliasedDefinition : -# 304| mu304_3(unknown) = UnmodeledDefinition : -# 305| r305_1(glval) = VariableAddress[i] : -# 305| r305_2(int) = Constant[0] : -# 305| m305_3(int) = Store : &:r305_1, r305_2 -#-----| Goto -> Block 1 - -# 306| Block 1 -# 306| m306_1(int) = Phi : from 0:m305_3, from 2:m306_11 -# 306| r306_2(glval) = VariableAddress[i] : -# 306| r306_3(int) = Load : &:r306_2, m306_1 -# 306| r306_4(int) = Constant[10] : -# 306| r306_5(bool) = CompareLT : r306_3, r306_4 -# 306| v306_6(void) = ConditionalBranch : r306_5 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 307| Block 2 -# 307| v307_1(void) = NoOp : -# 306| r306_7(int) = Constant[1] : -# 306| r306_8(glval) = VariableAddress[i] : -# 306| r306_9(int) = Load : &:r306_8, m306_1 -# 306| r306_10(int) = Add : r306_9, r306_7 -# 306| m306_11(int) = Store : &:r306_8, r306_10 -#-----| Goto (back edge) -> Block 1 - -# 309| Block 3 -# 309| v309_1(void) = NoOp : -# 304| v304_4(void) = ReturnVoid : -# 304| v304_5(void) = UnmodeledUse : mu* -# 304| v304_6(void) = AliasedUse : ~mu304_3 -# 304| v304_7(void) = ExitFunction : - -# 311| void For_InitConditionUpdate() -# 311| Block 0 -# 311| v311_1(void) = EnterFunction : -# 311| mu311_2(unknown) = AliasedDefinition : -# 311| mu311_3(unknown) = UnmodeledDefinition : -# 312| r312_1(glval) = VariableAddress[i] : -# 312| r312_2(int) = Constant[0] : -# 312| m312_3(int) = Store : &:r312_1, r312_2 -#-----| Goto -> Block 1 - -# 312| Block 1 -# 312| m312_4(int) = Phi : from 0:m312_3, from 2:m312_14 -# 312| r312_5(glval) = VariableAddress[i] : -# 312| r312_6(int) = Load : &:r312_5, m312_4 -# 312| r312_7(int) = Constant[10] : -# 312| r312_8(bool) = CompareLT : r312_6, r312_7 -# 312| v312_9(void) = ConditionalBranch : r312_8 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 313| Block 2 -# 313| v313_1(void) = NoOp : -# 312| r312_10(int) = Constant[1] : -# 312| r312_11(glval) = VariableAddress[i] : -# 312| r312_12(int) = Load : &:r312_11, m312_4 -# 312| r312_13(int) = Add : r312_12, r312_10 -# 312| m312_14(int) = Store : &:r312_11, r312_13 -#-----| Goto (back edge) -> Block 1 - -# 315| Block 3 -# 315| v315_1(void) = NoOp : -# 311| v311_4(void) = ReturnVoid : -# 311| v311_5(void) = UnmodeledUse : mu* -# 311| v311_6(void) = AliasedUse : ~mu311_3 -# 311| v311_7(void) = ExitFunction : - -# 317| void For_Break() -# 317| Block 0 -# 317| v317_1(void) = EnterFunction : -# 317| mu317_2(unknown) = AliasedDefinition : -# 317| mu317_3(unknown) = UnmodeledDefinition : -# 318| r318_1(glval) = VariableAddress[i] : -# 318| r318_2(int) = Constant[0] : -# 318| m318_3(int) = Store : &:r318_1, r318_2 -#-----| Goto -> Block 1 - -# 318| Block 1 -# 318| m318_4(int) = Phi : from 0:m318_3, from 2:m318_14 -# 318| r318_5(glval) = VariableAddress[i] : -# 318| r318_6(int) = Load : &:r318_5, m318_4 -# 318| r318_7(int) = Constant[10] : -# 318| r318_8(bool) = CompareLT : r318_6, r318_7 -# 318| v318_9(void) = ConditionalBranch : r318_8 -#-----| False -> Block 5 -#-----| True -> Block 3 - -# 318| Block 2 -# 318| r318_10(int) = Constant[1] : -# 318| r318_11(glval) = VariableAddress[i] : -# 318| r318_12(int) = Load : &:r318_11, m318_4 -# 318| r318_13(int) = Add : r318_12, r318_10 -# 318| m318_14(int) = Store : &:r318_11, r318_13 -#-----| Goto (back edge) -> Block 1 - -# 319| Block 3 -# 319| r319_1(glval) = VariableAddress[i] : -# 319| r319_2(int) = Load : &:r319_1, m318_4 -# 319| r319_3(int) = Constant[5] : -# 319| r319_4(bool) = CompareEQ : r319_2, r319_3 -# 319| v319_5(void) = ConditionalBranch : r319_4 -#-----| False -> Block 2 -#-----| True -> Block 4 - -# 320| Block 4 -# 320| v320_1(void) = NoOp : -#-----| Goto -> Block 5 - -# 322| Block 5 -# 322| v322_1(void) = NoOp : -# 323| v323_1(void) = NoOp : -# 317| v317_4(void) = ReturnVoid : -# 317| v317_5(void) = UnmodeledUse : mu* -# 317| v317_6(void) = AliasedUse : ~mu317_3 -# 317| v317_7(void) = ExitFunction : - -# 325| void For_Continue_Update() -# 325| Block 0 -# 325| v325_1(void) = EnterFunction : -# 325| mu325_2(unknown) = AliasedDefinition : -# 325| mu325_3(unknown) = UnmodeledDefinition : -# 326| r326_1(glval) = VariableAddress[i] : -# 326| r326_2(int) = Constant[0] : -# 326| m326_3(int) = Store : &:r326_1, r326_2 -#-----| Goto -> Block 1 - -# 326| Block 1 -# 326| m326_4(int) = Phi : from 0:m326_3, from 4:m326_15 -# 326| r326_5(glval) = VariableAddress[i] : -# 326| r326_6(int) = Load : &:r326_5, m326_4 -# 326| r326_7(int) = Constant[10] : -# 326| r326_8(bool) = CompareLT : r326_6, r326_7 -# 326| v326_9(void) = ConditionalBranch : r326_8 -#-----| False -> Block 5 -#-----| True -> Block 2 - -# 327| Block 2 -# 327| r327_1(glval) = VariableAddress[i] : -# 327| r327_2(int) = Load : &:r327_1, m326_4 -# 327| r327_3(int) = Constant[5] : -# 327| r327_4(bool) = CompareEQ : r327_2, r327_3 -# 327| v327_5(void) = ConditionalBranch : r327_4 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 328| Block 3 -# 328| v328_1(void) = NoOp : -#-----| Goto -> Block 4 - -# 326| Block 4 -# 326| v326_10(void) = NoOp : -# 326| r326_11(int) = Constant[1] : -# 326| r326_12(glval) = VariableAddress[i] : -# 326| r326_13(int) = Load : &:r326_12, m326_4 -# 326| r326_14(int) = Add : r326_13, r326_11 -# 326| m326_15(int) = Store : &:r326_12, r326_14 -#-----| Goto (back edge) -> Block 1 - -# 331| Block 5 -# 331| v331_1(void) = NoOp : -# 325| v325_4(void) = ReturnVoid : -# 325| v325_5(void) = UnmodeledUse : mu* -# 325| v325_6(void) = AliasedUse : ~mu325_3 -# 325| v325_7(void) = ExitFunction : - -# 333| void For_Continue_NoUpdate() -# 333| Block 0 -# 333| v333_1(void) = EnterFunction : -# 333| mu333_2(unknown) = AliasedDefinition : -# 333| mu333_3(unknown) = UnmodeledDefinition : -# 334| r334_1(glval) = VariableAddress[i] : -# 334| r334_2(int) = Constant[0] : -# 334| m334_3(int) = Store : &:r334_1, r334_2 -#-----| Goto -> Block 1 - -# 334| Block 1 -# 334| r334_4(glval) = VariableAddress[i] : -# 334| r334_5(int) = Load : &:r334_4, m334_3 -# 334| r334_6(int) = Constant[10] : -# 334| r334_7(bool) = CompareLT : r334_5, r334_6 -# 334| v334_8(void) = ConditionalBranch : r334_7 -#-----| False -> Block 5 -#-----| True -> Block 2 - -# 335| Block 2 -# 335| r335_1(glval) = VariableAddress[i] : -# 335| r335_2(int) = Load : &:r335_1, m334_3 -# 335| r335_3(int) = Constant[5] : -# 335| r335_4(bool) = CompareEQ : r335_2, r335_3 -# 335| v335_5(void) = ConditionalBranch : r335_4 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 336| Block 3 -# 336| v336_1(void) = NoOp : -#-----| Goto -> Block 4 - -# 334| Block 4 -# 334| v334_9(void) = NoOp : -#-----| Goto (back edge) -> Block 1 - -# 339| Block 5 -# 339| v339_1(void) = NoOp : -# 333| v333_4(void) = ReturnVoid : -# 333| v333_5(void) = UnmodeledUse : mu* -# 333| v333_6(void) = AliasedUse : ~mu333_3 -# 333| v333_7(void) = ExitFunction : - -# 341| int Dereference(int*) -# 341| Block 0 -# 341| v341_1(void) = EnterFunction : -# 341| mu341_2(unknown) = AliasedDefinition : -# 341| mu341_3(unknown) = UnmodeledDefinition : -# 341| r341_4(glval) = VariableAddress[p] : -# 341| m341_5(int *) = InitializeParameter[p] : &:r341_4 -# 341| r341_6(int *) = Load : &:r341_4, m341_5 -# 341| mu341_7(unknown) = InitializeIndirection[p] : &:r341_6 -# 342| r342_1(int) = Constant[1] : -# 342| r342_2(glval) = VariableAddress[p] : -# 342| r342_3(int *) = Load : &:r342_2, m341_5 -# 342| r342_4(glval) = CopyValue : r342_3 -# 342| mu342_5(int) = Store : &:r342_4, r342_1 -# 343| r343_1(glval) = VariableAddress[#return] : -# 343| r343_2(glval) = VariableAddress[p] : -# 343| r343_3(int *) = Load : &:r343_2, m341_5 -# 343| r343_4(int) = Load : &:r343_3, ~mu341_3 -# 343| m343_5(int) = Store : &:r343_1, r343_4 -# 341| v341_8(void) = ReturnIndirection : &:r341_6, ~mu341_3 -# 341| r341_9(glval) = VariableAddress[#return] : -# 341| v341_10(void) = ReturnValue : &:r341_9, m343_5 -# 341| v341_11(void) = UnmodeledUse : mu* -# 341| v341_12(void) = AliasedUse : ~mu341_3 -# 341| v341_13(void) = ExitFunction : - -# 348| int* AddressOf() -# 348| Block 0 -# 348| v348_1(void) = EnterFunction : -# 348| mu348_2(unknown) = AliasedDefinition : -# 348| mu348_3(unknown) = UnmodeledDefinition : -# 349| r349_1(glval) = VariableAddress[#return] : -# 349| r349_2(glval) = VariableAddress[g] : -# 349| r349_3(int *) = CopyValue : r349_2 -# 349| m349_4(int *) = Store : &:r349_1, r349_3 -# 348| r348_4(glval) = VariableAddress[#return] : -# 348| v348_5(void) = ReturnValue : &:r348_4, m349_4 -# 348| v348_6(void) = UnmodeledUse : mu* -# 348| v348_7(void) = AliasedUse : ~mu348_3 -# 348| v348_8(void) = ExitFunction : - -# 352| void Break(int) -# 352| Block 0 -# 352| v352_1(void) = EnterFunction : -# 352| mu352_2(unknown) = AliasedDefinition : -# 352| mu352_3(unknown) = UnmodeledDefinition : -# 352| r352_4(glval) = VariableAddress[n] : -# 352| m352_5(int) = InitializeParameter[n] : &:r352_4 -#-----| Goto -> Block 5 - -# 354| Block 1 -# 354| r354_1(glval) = VariableAddress[n] : -# 354| r354_2(int) = Load : &:r354_1, m353_1 -# 354| r354_3(int) = Constant[1] : -# 354| r354_4(bool) = CompareEQ : r354_2, r354_3 -# 354| v354_5(void) = ConditionalBranch : r354_4 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 355| Block 2 -# 355| v355_1(void) = NoOp : -#-----| Goto -> Block 4 - -# 356| Block 3 -# 356| r356_1(int) = Constant[1] : -# 356| r356_2(glval) = VariableAddress[n] : -# 356| r356_3(int) = Load : &:r356_2, m353_1 -# 356| r356_4(int) = Sub : r356_3, r356_1 -# 356| m356_5(int) = Store : &:r356_2, r356_4 -#-----| Goto (back edge) -> Block 5 - -# 357| Block 4 -# 357| v357_1(void) = NoOp : -# 358| v358_1(void) = NoOp : -# 352| v352_6(void) = ReturnVoid : -# 352| v352_7(void) = UnmodeledUse : mu* -# 352| v352_8(void) = AliasedUse : ~mu352_3 -# 352| v352_9(void) = ExitFunction : - -# 353| Block 5 -# 353| m353_1(int) = Phi : from 0:m352_5, from 3:m356_5 -# 353| r353_2(glval) = VariableAddress[n] : -# 353| r353_3(int) = Load : &:r353_2, m353_1 -# 353| r353_4(int) = Constant[0] : -# 353| r353_5(bool) = CompareGT : r353_3, r353_4 -# 353| v353_6(void) = ConditionalBranch : r353_5 -#-----| False -> Block 4 -#-----| True -> Block 1 - -# 360| void Continue(int) -# 360| Block 0 -# 360| v360_1(void) = EnterFunction : -# 360| mu360_2(unknown) = AliasedDefinition : -# 360| mu360_3(unknown) = UnmodeledDefinition : -# 360| r360_4(glval) = VariableAddress[n] : -# 360| m360_5(int) = InitializeParameter[n] : &:r360_4 -#-----| Goto -> Block 1 - -# 362| Block 1 -# 362| m362_1(int) = Phi : from 0:m360_5, from 4:m361_1 -# 362| r362_2(glval) = VariableAddress[n] : -# 362| r362_3(int) = Load : &:r362_2, m362_1 -# 362| r362_4(int) = Constant[1] : -# 362| r362_5(bool) = CompareEQ : r362_3, r362_4 -# 362| v362_6(void) = ConditionalBranch : r362_5 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 363| Block 2 -# 363| v363_1(void) = NoOp : -#-----| Goto -> Block 4 - -# 365| Block 3 -# 365| r365_1(int) = Constant[1] : -# 365| r365_2(glval) = VariableAddress[n] : -# 365| r365_3(int) = Load : &:r365_2, m362_1 -# 365| r365_4(int) = Sub : r365_3, r365_1 -# 365| m365_5(int) = Store : &:r365_2, r365_4 -#-----| Goto -> Block 4 - -# 361| Block 4 -# 361| m361_1(int) = Phi : from 2:m362_1, from 3:m365_5 -# 361| v361_2(void) = NoOp : -# 366| r366_1(glval) = VariableAddress[n] : -# 366| r366_2(int) = Load : &:r366_1, m361_1 -# 366| r366_3(int) = Constant[0] : -# 366| r366_4(bool) = CompareGT : r366_2, r366_3 -# 366| v366_5(void) = ConditionalBranch : r366_4 -#-----| False -> Block 5 -#-----| True (back edge) -> Block 1 - -# 367| Block 5 -# 367| v367_1(void) = NoOp : -# 360| v360_6(void) = ReturnVoid : -# 360| v360_7(void) = UnmodeledUse : mu* -# 360| v360_8(void) = AliasedUse : ~mu360_3 -# 360| v360_9(void) = ExitFunction : - -# 372| void Call() -# 372| Block 0 -# 372| v372_1(void) = EnterFunction : -# 372| mu372_2(unknown) = AliasedDefinition : -# 372| mu372_3(unknown) = UnmodeledDefinition : -# 373| r373_1(glval) = FunctionAddress[VoidFunc] : -# 373| v373_2(void) = Call : func:r373_1 -# 373| mu373_3(unknown) = ^CallSideEffect : ~mu372_3 -# 374| v374_1(void) = NoOp : -# 372| v372_4(void) = ReturnVoid : -# 372| v372_5(void) = UnmodeledUse : mu* -# 372| v372_6(void) = AliasedUse : ~mu372_3 -# 372| v372_7(void) = ExitFunction : - -# 376| int CallAdd(int, int) -# 376| Block 0 -# 376| v376_1(void) = EnterFunction : -# 376| mu376_2(unknown) = AliasedDefinition : -# 376| mu376_3(unknown) = UnmodeledDefinition : -# 376| r376_4(glval) = VariableAddress[x] : -# 376| m376_5(int) = InitializeParameter[x] : &:r376_4 -# 376| r376_6(glval) = VariableAddress[y] : -# 376| m376_7(int) = InitializeParameter[y] : &:r376_6 -# 377| r377_1(glval) = VariableAddress[#return] : -# 377| r377_2(glval) = FunctionAddress[Add] : -# 377| r377_3(glval) = VariableAddress[x] : -# 377| r377_4(int) = Load : &:r377_3, m376_5 -# 377| r377_5(glval) = VariableAddress[y] : -# 377| r377_6(int) = Load : &:r377_5, m376_7 -# 377| r377_7(int) = Call : func:r377_2, 0:r377_4, 1:r377_6 -# 377| mu377_8(unknown) = ^CallSideEffect : ~mu376_3 -# 377| m377_9(int) = Store : &:r377_1, r377_7 -# 376| r376_8(glval) = VariableAddress[#return] : -# 376| v376_9(void) = ReturnValue : &:r376_8, m377_9 -# 376| v376_10(void) = UnmodeledUse : mu* -# 376| v376_11(void) = AliasedUse : ~mu376_3 -# 376| v376_12(void) = ExitFunction : - -# 380| int Comma(int, int) -# 380| Block 0 -# 380| v380_1(void) = EnterFunction : -# 380| mu380_2(unknown) = AliasedDefinition : -# 380| mu380_3(unknown) = UnmodeledDefinition : -# 380| r380_4(glval) = VariableAddress[x] : -# 380| m380_5(int) = InitializeParameter[x] : &:r380_4 -# 380| r380_6(glval) = VariableAddress[y] : -# 380| m380_7(int) = InitializeParameter[y] : &:r380_6 -# 381| r381_1(glval) = VariableAddress[#return] : -# 381| r381_2(glval) = FunctionAddress[VoidFunc] : -# 381| v381_3(void) = Call : func:r381_2 -# 381| mu381_4(unknown) = ^CallSideEffect : ~mu380_3 -# 381| r381_5(glval) = FunctionAddress[CallAdd] : -# 381| r381_6(glval) = VariableAddress[x] : -# 381| r381_7(int) = Load : &:r381_6, m380_5 -# 381| r381_8(glval) = VariableAddress[y] : -# 381| r381_9(int) = Load : &:r381_8, m380_7 -# 381| r381_10(int) = Call : func:r381_5, 0:r381_7, 1:r381_9 -# 381| mu381_11(unknown) = ^CallSideEffect : ~mu380_3 -# 381| r381_12(int) = CopyValue : r381_10 -# 381| m381_13(int) = Store : &:r381_1, r381_12 -# 380| r380_8(glval) = VariableAddress[#return] : -# 380| v380_9(void) = ReturnValue : &:r380_8, m381_13 -# 380| v380_10(void) = UnmodeledUse : mu* -# 380| v380_11(void) = AliasedUse : ~mu380_3 -# 380| v380_12(void) = ExitFunction : - -# 384| void Switch(int) -# 384| Block 0 -# 384| v384_1(void) = EnterFunction : -# 384| mu384_2(unknown) = AliasedDefinition : -# 384| mu384_3(unknown) = UnmodeledDefinition : -# 384| r384_4(glval) = VariableAddress[x] : -# 384| m384_5(int) = InitializeParameter[x] : &:r384_4 -# 385| r385_1(glval) = VariableAddress[y] : -# 385| m385_2(int) = Uninitialized[y] : &:r385_1 -# 386| r386_1(glval) = VariableAddress[x] : -# 386| r386_2(int) = Load : &:r386_1, m384_5 -# 386| v386_3(void) = Switch : r386_2 -#-----| Case[-1] -> Block 1 -#-----| Case[1] -> Block 2 -#-----| Case[2] -> Block 3 -#-----| Case[3] -> Block 4 -#-----| Case[4] -> Block 5 -#-----| Default -> Block 6 - -# 389| Block 1 -# 389| v389_1(void) = NoOp : -# 390| r390_1(int) = Constant[-1] : -# 390| r390_2(glval) = VariableAddress[y] : -# 390| m390_3(int) = Store : &:r390_2, r390_1 -# 391| v391_1(void) = NoOp : -#-----| Goto -> Block 7 - -# 393| Block 2 -# 393| v393_1(void) = NoOp : -#-----| Goto -> Block 3 - -# 394| Block 3 -# 394| v394_1(void) = NoOp : -# 395| r395_1(int) = Constant[1] : -# 395| r395_2(glval) = VariableAddress[y] : -# 395| m395_3(int) = Store : &:r395_2, r395_1 -# 396| v396_1(void) = NoOp : -#-----| Goto -> Block 7 - -# 398| Block 4 -# 398| v398_1(void) = NoOp : -# 399| r399_1(int) = Constant[3] : -# 399| r399_2(glval) = VariableAddress[y] : -# 399| m399_3(int) = Store : &:r399_2, r399_1 -#-----| Goto -> Block 5 - -# 400| Block 5 -# 400| v400_1(void) = NoOp : -# 401| r401_1(int) = Constant[4] : -# 401| r401_2(glval) = VariableAddress[y] : -# 401| m401_3(int) = Store : &:r401_2, r401_1 -# 402| v402_1(void) = NoOp : -#-----| Goto -> Block 7 - -# 404| Block 6 -# 404| v404_1(void) = NoOp : -# 405| r405_1(int) = Constant[0] : -# 405| r405_2(glval) = VariableAddress[y] : -# 405| m405_3(int) = Store : &:r405_2, r405_1 -# 406| v406_1(void) = NoOp : -#-----| Goto -> Block 7 - -# 409| Block 7 -# 409| v409_1(void) = NoOp : -# 410| v410_1(void) = NoOp : -# 384| v384_6(void) = ReturnVoid : -# 384| v384_7(void) = UnmodeledUse : mu* -# 384| v384_8(void) = AliasedUse : ~mu384_3 -# 384| v384_9(void) = ExitFunction : - -# 422| Point ReturnStruct(Point) -# 422| Block 0 -# 422| v422_1(void) = EnterFunction : -# 422| mu422_2(unknown) = AliasedDefinition : -# 422| mu422_3(unknown) = UnmodeledDefinition : -# 422| r422_4(glval) = VariableAddress[pt] : -# 422| m422_5(Point) = InitializeParameter[pt] : &:r422_4 -# 423| r423_1(glval) = VariableAddress[#return] : -# 423| r423_2(glval) = VariableAddress[pt] : -# 423| r423_3(Point) = Load : &:r423_2, m422_5 -# 423| m423_4(Point) = Store : &:r423_1, r423_3 -# 422| r422_6(glval) = VariableAddress[#return] : -# 422| v422_7(void) = ReturnValue : &:r422_6, m423_4 -# 422| v422_8(void) = UnmodeledUse : mu* -# 422| v422_9(void) = AliasedUse : ~mu422_3 -# 422| v422_10(void) = ExitFunction : - -# 426| void FieldAccess() -# 426| Block 0 -# 426| v426_1(void) = EnterFunction : -# 426| mu426_2(unknown) = AliasedDefinition : -# 426| mu426_3(unknown) = UnmodeledDefinition : -# 427| r427_1(glval) = VariableAddress[pt] : -# 427| mu427_2(Point) = Uninitialized[pt] : &:r427_1 -# 428| r428_1(int) = Constant[5] : -# 428| r428_2(glval) = VariableAddress[pt] : -# 428| r428_3(glval) = FieldAddress[x] : r428_2 -# 428| mu428_4(int) = Store : &:r428_3, r428_1 -# 429| r429_1(glval) = VariableAddress[pt] : -# 429| r429_2(glval) = FieldAddress[x] : r429_1 -# 429| r429_3(int) = Load : &:r429_2, ~mu426_3 -# 429| r429_4(glval) = VariableAddress[pt] : -# 429| r429_5(glval) = FieldAddress[y] : r429_4 -# 429| mu429_6(int) = Store : &:r429_5, r429_3 -# 430| r430_1(glval) = VariableAddress[p] : -# 430| r430_2(glval) = VariableAddress[pt] : -# 430| r430_3(glval) = FieldAddress[y] : r430_2 -# 430| r430_4(int *) = CopyValue : r430_3 -# 430| m430_5(int *) = Store : &:r430_1, r430_4 -# 431| v431_1(void) = NoOp : -# 426| v426_4(void) = ReturnVoid : -# 426| v426_5(void) = UnmodeledUse : mu* -# 426| v426_6(void) = AliasedUse : ~mu426_3 -# 426| v426_7(void) = ExitFunction : - -# 433| void LogicalOr(bool, bool) -# 433| Block 0 -# 433| v433_1(void) = EnterFunction : -# 433| mu433_2(unknown) = AliasedDefinition : -# 433| mu433_3(unknown) = UnmodeledDefinition : -# 433| r433_4(glval) = VariableAddress[a] : -# 433| m433_5(bool) = InitializeParameter[a] : &:r433_4 -# 433| r433_6(glval) = VariableAddress[b] : -# 433| m433_7(bool) = InitializeParameter[b] : &:r433_6 -# 434| r434_1(glval) = VariableAddress[x] : -# 434| m434_2(int) = Uninitialized[x] : &:r434_1 -# 435| r435_1(glval) = VariableAddress[a] : -# 435| r435_2(bool) = Load : &:r435_1, m433_5 -# 435| v435_3(void) = ConditionalBranch : r435_2 -#-----| False -> Block 1 -#-----| True -> Block 2 - -# 435| Block 1 -# 435| r435_4(glval) = VariableAddress[b] : -# 435| r435_5(bool) = Load : &:r435_4, m433_7 -# 435| v435_6(void) = ConditionalBranch : r435_5 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 436| Block 2 -# 436| r436_1(int) = Constant[7] : -# 436| r436_2(glval) = VariableAddress[x] : -# 436| m436_3(int) = Store : &:r436_2, r436_1 -#-----| Goto -> Block 3 - -# 439| Block 3 -# 439| r439_1(glval) = VariableAddress[a] : -# 439| r439_2(bool) = Load : &:r439_1, m433_5 -# 439| v439_3(void) = ConditionalBranch : r439_2 -#-----| False -> Block 4 -#-----| True -> Block 5 - -# 439| Block 4 -# 439| r439_4(glval) = VariableAddress[b] : -# 439| r439_5(bool) = Load : &:r439_4, m433_7 -# 439| v439_6(void) = ConditionalBranch : r439_5 -#-----| False -> Block 6 -#-----| True -> Block 5 - -# 440| Block 5 -# 440| r440_1(int) = Constant[1] : -# 440| r440_2(glval) = VariableAddress[x] : -# 440| m440_3(int) = Store : &:r440_2, r440_1 -#-----| Goto -> Block 7 - -# 443| Block 6 -# 443| r443_1(int) = Constant[5] : -# 443| r443_2(glval) = VariableAddress[x] : -# 443| m443_3(int) = Store : &:r443_2, r443_1 -#-----| Goto -> Block 7 - -# 445| Block 7 -# 445| v445_1(void) = NoOp : -# 433| v433_8(void) = ReturnVoid : -# 433| v433_9(void) = UnmodeledUse : mu* -# 433| v433_10(void) = AliasedUse : ~mu433_3 -# 433| v433_11(void) = ExitFunction : - -# 447| void LogicalAnd(bool, bool) -# 447| Block 0 -# 447| v447_1(void) = EnterFunction : -# 447| mu447_2(unknown) = AliasedDefinition : -# 447| mu447_3(unknown) = UnmodeledDefinition : -# 447| r447_4(glval) = VariableAddress[a] : -# 447| m447_5(bool) = InitializeParameter[a] : &:r447_4 -# 447| r447_6(glval) = VariableAddress[b] : -# 447| m447_7(bool) = InitializeParameter[b] : &:r447_6 -# 448| r448_1(glval) = VariableAddress[x] : -# 448| m448_2(int) = Uninitialized[x] : &:r448_1 -# 449| r449_1(glval) = VariableAddress[a] : -# 449| r449_2(bool) = Load : &:r449_1, m447_5 -# 449| v449_3(void) = ConditionalBranch : r449_2 -#-----| False -> Block 3 -#-----| True -> Block 1 - -# 449| Block 1 -# 449| r449_4(glval) = VariableAddress[b] : -# 449| r449_5(bool) = Load : &:r449_4, m447_7 -# 449| v449_6(void) = ConditionalBranch : r449_5 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 450| Block 2 -# 450| r450_1(int) = Constant[7] : -# 450| r450_2(glval) = VariableAddress[x] : -# 450| m450_3(int) = Store : &:r450_2, r450_1 -#-----| Goto -> Block 3 - -# 453| Block 3 -# 453| r453_1(glval) = VariableAddress[a] : -# 453| r453_2(bool) = Load : &:r453_1, m447_5 -# 453| v453_3(void) = ConditionalBranch : r453_2 -#-----| False -> Block 6 -#-----| True -> Block 4 - -# 453| Block 4 -# 453| r453_4(glval) = VariableAddress[b] : -# 453| r453_5(bool) = Load : &:r453_4, m447_7 -# 453| v453_6(void) = ConditionalBranch : r453_5 -#-----| False -> Block 6 -#-----| True -> Block 5 - -# 454| Block 5 -# 454| r454_1(int) = Constant[1] : -# 454| r454_2(glval) = VariableAddress[x] : -# 454| m454_3(int) = Store : &:r454_2, r454_1 -#-----| Goto -> Block 7 - -# 457| Block 6 -# 457| r457_1(int) = Constant[5] : -# 457| r457_2(glval) = VariableAddress[x] : -# 457| m457_3(int) = Store : &:r457_2, r457_1 -#-----| Goto -> Block 7 - -# 459| Block 7 -# 459| v459_1(void) = NoOp : -# 447| v447_8(void) = ReturnVoid : -# 447| v447_9(void) = UnmodeledUse : mu* -# 447| v447_10(void) = AliasedUse : ~mu447_3 -# 447| v447_11(void) = ExitFunction : - -# 461| void LogicalNot(bool, bool) -# 461| Block 0 -# 461| v461_1(void) = EnterFunction : -# 461| mu461_2(unknown) = AliasedDefinition : -# 461| mu461_3(unknown) = UnmodeledDefinition : -# 461| r461_4(glval) = VariableAddress[a] : -# 461| m461_5(bool) = InitializeParameter[a] : &:r461_4 -# 461| r461_6(glval) = VariableAddress[b] : -# 461| m461_7(bool) = InitializeParameter[b] : &:r461_6 -# 462| r462_1(glval) = VariableAddress[x] : -# 462| m462_2(int) = Uninitialized[x] : &:r462_1 -# 463| r463_1(glval) = VariableAddress[a] : -# 463| r463_2(bool) = Load : &:r463_1, m461_5 -# 463| v463_3(void) = ConditionalBranch : r463_2 -#-----| False -> Block 1 -#-----| True -> Block 2 - -# 464| Block 1 -# 464| r464_1(int) = Constant[1] : -# 464| r464_2(glval) = VariableAddress[x] : -# 464| m464_3(int) = Store : &:r464_2, r464_1 -#-----| Goto -> Block 2 - -# 467| Block 2 -# 467| r467_1(glval) = VariableAddress[a] : -# 467| r467_2(bool) = Load : &:r467_1, m461_5 -# 467| v467_3(void) = ConditionalBranch : r467_2 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 467| Block 3 -# 467| r467_4(glval) = VariableAddress[b] : -# 467| r467_5(bool) = Load : &:r467_4, m461_7 -# 467| v467_6(void) = ConditionalBranch : r467_5 -#-----| False -> Block 4 -#-----| True -> Block 5 - -# 468| Block 4 -# 468| r468_1(int) = Constant[2] : -# 468| r468_2(glval) = VariableAddress[x] : -# 468| m468_3(int) = Store : &:r468_2, r468_1 -#-----| Goto -> Block 6 - -# 471| Block 5 -# 471| r471_1(int) = Constant[3] : -# 471| r471_2(glval) = VariableAddress[x] : -# 471| m471_3(int) = Store : &:r471_2, r471_1 -#-----| Goto -> Block 6 - -# 473| Block 6 -# 473| v473_1(void) = NoOp : -# 461| v461_8(void) = ReturnVoid : -# 461| v461_9(void) = UnmodeledUse : mu* -# 461| v461_10(void) = AliasedUse : ~mu461_3 -# 461| v461_11(void) = ExitFunction : - -# 475| void ConditionValues(bool, bool) -# 475| Block 0 -# 475| v475_1(void) = EnterFunction : -# 475| mu475_2(unknown) = AliasedDefinition : -# 475| mu475_3(unknown) = UnmodeledDefinition : -# 475| r475_4(glval) = VariableAddress[a] : -# 475| m475_5(bool) = InitializeParameter[a] : &:r475_4 -# 475| r475_6(glval) = VariableAddress[b] : -# 475| m475_7(bool) = InitializeParameter[b] : &:r475_6 -# 476| r476_1(glval) = VariableAddress[x] : -# 476| m476_2(bool) = Uninitialized[x] : &:r476_1 -# 477| r477_1(glval) = VariableAddress[a] : -# 477| r477_2(bool) = Load : &:r477_1, m475_5 -# 477| v477_3(void) = ConditionalBranch : r477_2 -#-----| False -> Block 10 -#-----| True -> Block 1 - -# 477| Block 1 -# 477| r477_4(glval) = VariableAddress[b] : -# 477| r477_5(bool) = Load : &:r477_4, m475_7 -# 477| v477_6(void) = ConditionalBranch : r477_5 -#-----| False -> Block 10 -#-----| True -> Block 12 - -# 478| Block 2 -# 478| r478_1(glval) = VariableAddress[#temp478:9] : -# 478| r478_2(bool) = Constant[0] : -# 478| m478_3(bool) = Store : &:r478_1, r478_2 -#-----| Goto -> Block 3 - -# 478| Block 3 -# 478| m478_4(bool) = Phi : from 2:m478_3, from 4:m478_11 -# 478| r478_5(glval) = VariableAddress[#temp478:9] : -# 478| r478_6(bool) = Load : &:r478_5, m478_4 -# 478| r478_7(glval) = VariableAddress[x] : -# 478| m478_8(bool) = Store : &:r478_7, r478_6 -# 479| r479_1(glval) = VariableAddress[a] : -# 479| r479_2(bool) = Load : &:r479_1, m475_5 -# 479| v479_3(void) = ConditionalBranch : r479_2 -#-----| False -> Block 9 -#-----| True -> Block 8 - -# 478| Block 4 -# 478| r478_9(glval) = VariableAddress[#temp478:9] : -# 478| r478_10(bool) = Constant[1] : -# 478| m478_11(bool) = Store : &:r478_9, r478_10 -#-----| Goto -> Block 3 - -# 478| Block 5 -# 478| r478_12(glval) = VariableAddress[b] : -# 478| r478_13(bool) = Load : &:r478_12, m475_7 -# 478| v478_14(void) = ConditionalBranch : r478_13 -#-----| False -> Block 2 -#-----| True -> Block 4 - -# 479| Block 6 -# 479| r479_4(glval) = VariableAddress[#temp479:11] : -# 479| r479_5(bool) = Constant[0] : -# 479| m479_6(bool) = Store : &:r479_4, r479_5 -#-----| Goto -> Block 7 - -# 479| Block 7 -# 479| m479_7(bool) = Phi : from 6:m479_6, from 8:m479_15 -# 479| r479_8(glval) = VariableAddress[#temp479:11] : -# 479| r479_9(bool) = Load : &:r479_8, m479_7 -# 479| r479_10(bool) = LogicalNot : r479_9 -# 479| r479_11(glval) = VariableAddress[x] : -# 479| m479_12(bool) = Store : &:r479_11, r479_10 -# 480| v480_1(void) = NoOp : -# 475| v475_8(void) = ReturnVoid : -# 475| v475_9(void) = UnmodeledUse : mu* -# 475| v475_10(void) = AliasedUse : ~mu475_3 -# 475| v475_11(void) = ExitFunction : - -# 479| Block 8 -# 479| r479_13(glval) = VariableAddress[#temp479:11] : -# 479| r479_14(bool) = Constant[1] : -# 479| m479_15(bool) = Store : &:r479_13, r479_14 -#-----| Goto -> Block 7 - -# 479| Block 9 -# 479| r479_16(glval) = VariableAddress[b] : -# 479| r479_17(bool) = Load : &:r479_16, m475_7 -# 479| v479_18(void) = ConditionalBranch : r479_17 -#-----| False -> Block 6 -#-----| True -> Block 8 - -# 477| Block 10 -# 477| r477_7(glval) = VariableAddress[#temp477:9] : -# 477| r477_8(bool) = Constant[0] : -# 477| m477_9(bool) = Store : &:r477_7, r477_8 -#-----| Goto -> Block 11 - -# 477| Block 11 -# 477| m477_10(bool) = Phi : from 10:m477_9, from 12:m477_17 -# 477| r477_11(glval) = VariableAddress[#temp477:9] : -# 477| r477_12(bool) = Load : &:r477_11, m477_10 -# 477| r477_13(glval) = VariableAddress[x] : -# 477| m477_14(bool) = Store : &:r477_13, r477_12 -# 478| r478_15(glval) = VariableAddress[a] : -# 478| r478_16(bool) = Load : &:r478_15, m475_5 -# 478| v478_17(void) = ConditionalBranch : r478_16 -#-----| False -> Block 5 -#-----| True -> Block 4 - -# 477| Block 12 -# 477| r477_15(glval) = VariableAddress[#temp477:9] : -# 477| r477_16(bool) = Constant[1] : -# 477| m477_17(bool) = Store : &:r477_15, r477_16 -#-----| Goto -> Block 11 - -# 482| void Conditional(bool, int, int) -# 482| Block 0 -# 482| v482_1(void) = EnterFunction : -# 482| mu482_2(unknown) = AliasedDefinition : -# 482| mu482_3(unknown) = UnmodeledDefinition : -# 482| r482_4(glval) = VariableAddress[a] : -# 482| m482_5(bool) = InitializeParameter[a] : &:r482_4 -# 482| r482_6(glval) = VariableAddress[x] : -# 482| m482_7(int) = InitializeParameter[x] : &:r482_6 -# 482| r482_8(glval) = VariableAddress[y] : -# 482| m482_9(int) = InitializeParameter[y] : &:r482_8 -# 483| r483_1(glval) = VariableAddress[z] : -# 483| r483_2(glval) = VariableAddress[a] : -# 483| r483_3(bool) = Load : &:r483_2, m482_5 -# 483| v483_4(void) = ConditionalBranch : r483_3 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 483| Block 1 -# 483| r483_5(glval) = VariableAddress[x] : -# 483| r483_6(int) = Load : &:r483_5, m482_7 -# 483| r483_7(glval) = VariableAddress[#temp483:13] : -# 483| m483_8(int) = Store : &:r483_7, r483_6 -#-----| Goto -> Block 3 - -# 483| Block 2 -# 483| r483_9(glval) = VariableAddress[y] : -# 483| r483_10(int) = Load : &:r483_9, m482_9 -# 483| r483_11(glval) = VariableAddress[#temp483:13] : -# 483| m483_12(int) = Store : &:r483_11, r483_10 -#-----| Goto -> Block 3 - -# 483| Block 3 -# 483| m483_13(int) = Phi : from 1:m483_8, from 2:m483_12 -# 483| r483_14(glval) = VariableAddress[#temp483:13] : -# 483| r483_15(int) = Load : &:r483_14, m483_13 -# 483| m483_16(int) = Store : &:r483_1, r483_15 -# 484| v484_1(void) = NoOp : -# 482| v482_10(void) = ReturnVoid : -# 482| v482_11(void) = UnmodeledUse : mu* -# 482| v482_12(void) = AliasedUse : ~mu482_3 -# 482| v482_13(void) = ExitFunction : - -# 486| void Conditional_LValue(bool) -# 486| Block 0 -# 486| v486_1(void) = EnterFunction : -# 486| mu486_2(unknown) = AliasedDefinition : -# 486| mu486_3(unknown) = UnmodeledDefinition : -# 486| r486_4(glval) = VariableAddress[a] : -# 486| m486_5(bool) = InitializeParameter[a] : &:r486_4 -# 487| r487_1(glval) = VariableAddress[x] : -# 487| m487_2(int) = Uninitialized[x] : &:r487_1 -# 488| r488_1(glval) = VariableAddress[y] : -# 488| m488_2(int) = Uninitialized[y] : &:r488_1 -# 489| r489_1(int) = Constant[5] : -# 489| r489_2(glval) = VariableAddress[a] : -# 489| r489_3(bool) = Load : &:r489_2, m486_5 -# 489| v489_4(void) = ConditionalBranch : r489_3 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 489| Block 1 -# 489| m489_5(glval) = Phi : from 2:m489_11, from 3:m489_14 -# 489| r489_6(glval) = VariableAddress[#temp489:6] : -# 489| r489_7(glval) = Load : &:r489_6, m489_5 -# 489| mu489_8(int) = Store : &:r489_7, r489_1 -# 490| v490_1(void) = NoOp : -# 486| v486_6(void) = ReturnVoid : -# 486| v486_7(void) = UnmodeledUse : mu* -# 486| v486_8(void) = AliasedUse : ~mu486_3 -# 486| v486_9(void) = ExitFunction : - -# 489| Block 2 -# 489| r489_9(glval) = VariableAddress[x] : -# 489| r489_10(glval) = VariableAddress[#temp489:6] : -# 489| m489_11(glval) = Store : &:r489_10, r489_9 -#-----| Goto -> Block 1 - -# 489| Block 3 -# 489| r489_12(glval) = VariableAddress[y] : -# 489| r489_13(glval) = VariableAddress[#temp489:6] : -# 489| m489_14(glval) = Store : &:r489_13, r489_12 -#-----| Goto -> Block 1 - -# 492| void Conditional_Void(bool) -# 492| Block 0 -# 492| v492_1(void) = EnterFunction : -# 492| mu492_2(unknown) = AliasedDefinition : -# 492| mu492_3(unknown) = UnmodeledDefinition : -# 492| r492_4(glval) = VariableAddress[a] : -# 492| m492_5(bool) = InitializeParameter[a] : &:r492_4 -# 493| r493_1(glval) = VariableAddress[a] : -# 493| r493_2(bool) = Load : &:r493_1, m492_5 -# 493| v493_3(void) = ConditionalBranch : r493_2 -#-----| False -> Block 1 -#-----| True -> Block 3 - -# 493| Block 1 -# 493| r493_4(glval) = FunctionAddress[VoidFunc] : -# 493| v493_5(void) = Call : func:r493_4 -# 493| mu493_6(unknown) = ^CallSideEffect : ~mu492_3 -#-----| Goto -> Block 2 - -# 494| Block 2 -# 494| v494_1(void) = NoOp : -# 492| v492_6(void) = ReturnVoid : -# 492| v492_7(void) = UnmodeledUse : mu* -# 492| v492_8(void) = AliasedUse : ~mu492_3 -# 492| v492_9(void) = ExitFunction : - -# 493| Block 3 -# 493| r493_7(glval) = FunctionAddress[VoidFunc] : -# 493| v493_8(void) = Call : func:r493_7 -# 493| mu493_9(unknown) = ^CallSideEffect : ~mu492_3 -#-----| Goto -> Block 2 - -# 496| void Nullptr() -# 496| Block 0 -# 496| v496_1(void) = EnterFunction : -# 496| mu496_2(unknown) = AliasedDefinition : -# 496| mu496_3(unknown) = UnmodeledDefinition : -# 497| r497_1(glval) = VariableAddress[p] : -# 497| r497_2(int *) = Constant[0] : -# 497| m497_3(int *) = Store : &:r497_1, r497_2 -# 498| r498_1(glval) = VariableAddress[q] : -# 498| r498_2(int *) = Constant[0] : -# 498| m498_3(int *) = Store : &:r498_1, r498_2 -# 499| r499_1(int *) = Constant[0] : -# 499| r499_2(glval) = VariableAddress[p] : -# 499| m499_3(int *) = Store : &:r499_2, r499_1 -# 500| r500_1(int *) = Constant[0] : -# 500| r500_2(glval) = VariableAddress[q] : -# 500| m500_3(int *) = Store : &:r500_2, r500_1 -# 501| v501_1(void) = NoOp : -# 496| v496_4(void) = ReturnVoid : -# 496| v496_5(void) = UnmodeledUse : mu* -# 496| v496_6(void) = AliasedUse : ~mu496_3 -# 496| v496_7(void) = ExitFunction : - -# 503| void InitList(int, float) -# 503| Block 0 -# 503| v503_1(void) = EnterFunction : -# 503| mu503_2(unknown) = AliasedDefinition : -# 503| mu503_3(unknown) = UnmodeledDefinition : -# 503| r503_4(glval) = VariableAddress[x] : -# 503| m503_5(int) = InitializeParameter[x] : &:r503_4 -# 503| r503_6(glval) = VariableAddress[f] : -# 503| m503_7(float) = InitializeParameter[f] : &:r503_6 -# 504| r504_1(glval) = VariableAddress[pt1] : -# 504| mu504_2(Point) = Uninitialized[pt1] : &:r504_1 -# 504| r504_3(glval) = FieldAddress[x] : r504_1 -# 504| r504_4(glval) = VariableAddress[x] : -# 504| r504_5(int) = Load : &:r504_4, m503_5 -# 504| mu504_6(int) = Store : &:r504_3, r504_5 -# 504| r504_7(glval) = FieldAddress[y] : r504_1 -# 504| r504_8(glval) = VariableAddress[f] : -# 504| r504_9(float) = Load : &:r504_8, m503_7 -# 504| r504_10(int) = Convert : r504_9 -# 504| mu504_11(int) = Store : &:r504_7, r504_10 -# 505| r505_1(glval) = VariableAddress[pt2] : -# 505| mu505_2(Point) = Uninitialized[pt2] : &:r505_1 -# 505| r505_3(glval) = FieldAddress[x] : r505_1 -# 505| r505_4(glval) = VariableAddress[x] : -# 505| r505_5(int) = Load : &:r505_4, m503_5 -# 505| mu505_6(int) = Store : &:r505_3, r505_5 -# 505| r505_7(glval) = FieldAddress[y] : r505_1 -# 505| r505_8(int) = Constant[0] : -# 505| mu505_9(int) = Store : &:r505_7, r505_8 -# 506| r506_1(glval) = VariableAddress[pt3] : -# 506| mu506_2(Point) = Uninitialized[pt3] : &:r506_1 -# 506| r506_3(glval) = FieldAddress[x] : r506_1 -# 506| r506_4(int) = Constant[0] : -# 506| mu506_5(int) = Store : &:r506_3, r506_4 -# 506| r506_6(glval) = FieldAddress[y] : r506_1 -# 506| r506_7(int) = Constant[0] : -# 506| mu506_8(int) = Store : &:r506_6, r506_7 -# 508| r508_1(glval) = VariableAddress[x1] : -# 508| r508_2(int) = Constant[1] : -# 508| m508_3(int) = Store : &:r508_1, r508_2 -# 509| r509_1(glval) = VariableAddress[x2] : -# 509| r509_2(int) = Constant[0] : -# 509| m509_3(int) = Store : &:r509_1, r509_2 -# 510| v510_1(void) = NoOp : -# 503| v503_8(void) = ReturnVoid : -# 503| v503_9(void) = UnmodeledUse : mu* -# 503| v503_10(void) = AliasedUse : ~mu503_3 -# 503| v503_11(void) = ExitFunction : - -# 512| void NestedInitList(int, float) -# 512| Block 0 -# 512| v512_1(void) = EnterFunction : -# 512| mu512_2(unknown) = AliasedDefinition : -# 512| mu512_3(unknown) = UnmodeledDefinition : -# 512| r512_4(glval) = VariableAddress[x] : -# 512| m512_5(int) = InitializeParameter[x] : &:r512_4 -# 512| r512_6(glval) = VariableAddress[f] : -# 512| m512_7(float) = InitializeParameter[f] : &:r512_6 -# 513| r513_1(glval) = VariableAddress[r1] : -# 513| mu513_2(Rect) = Uninitialized[r1] : &:r513_1 -# 513| r513_3(glval) = FieldAddress[topLeft] : r513_1 -# 513| r513_4(Point) = Constant[0] : -# 513| mu513_5(Point) = Store : &:r513_3, r513_4 -# 513| r513_6(glval) = FieldAddress[bottomRight] : r513_1 -# 513| r513_7(Point) = Constant[0] : -# 513| mu513_8(Point) = Store : &:r513_6, r513_7 -# 514| r514_1(glval) = VariableAddress[r2] : -# 514| mu514_2(Rect) = Uninitialized[r2] : &:r514_1 -# 514| r514_3(glval) = FieldAddress[topLeft] : r514_1 -# 514| r514_4(glval) = FieldAddress[x] : r514_3 -# 514| r514_5(glval) = VariableAddress[x] : -# 514| r514_6(int) = Load : &:r514_5, m512_5 -# 514| mu514_7(int) = Store : &:r514_4, r514_6 -# 514| r514_8(glval) = FieldAddress[y] : r514_3 -# 514| r514_9(glval) = VariableAddress[f] : -# 514| r514_10(float) = Load : &:r514_9, m512_7 -# 514| r514_11(int) = Convert : r514_10 -# 514| mu514_12(int) = Store : &:r514_8, r514_11 -# 514| r514_13(glval) = FieldAddress[bottomRight] : r514_1 -# 514| r514_14(Point) = Constant[0] : -# 514| mu514_15(Point) = Store : &:r514_13, r514_14 -# 515| r515_1(glval) = VariableAddress[r3] : -# 515| mu515_2(Rect) = Uninitialized[r3] : &:r515_1 -# 515| r515_3(glval) = FieldAddress[topLeft] : r515_1 -# 515| r515_4(glval) = FieldAddress[x] : r515_3 -# 515| r515_5(glval) = VariableAddress[x] : -# 515| r515_6(int) = Load : &:r515_5, m512_5 -# 515| mu515_7(int) = Store : &:r515_4, r515_6 -# 515| r515_8(glval) = FieldAddress[y] : r515_3 -# 515| r515_9(glval) = VariableAddress[f] : -# 515| r515_10(float) = Load : &:r515_9, m512_7 -# 515| r515_11(int) = Convert : r515_10 -# 515| mu515_12(int) = Store : &:r515_8, r515_11 -# 515| r515_13(glval) = FieldAddress[bottomRight] : r515_1 -# 515| r515_14(glval) = FieldAddress[x] : r515_13 -# 515| r515_15(glval) = VariableAddress[x] : -# 515| r515_16(int) = Load : &:r515_15, m512_5 -# 515| mu515_17(int) = Store : &:r515_14, r515_16 -# 515| r515_18(glval) = FieldAddress[y] : r515_13 -# 515| r515_19(glval) = VariableAddress[f] : -# 515| r515_20(float) = Load : &:r515_19, m512_7 -# 515| r515_21(int) = Convert : r515_20 -# 515| mu515_22(int) = Store : &:r515_18, r515_21 -# 516| r516_1(glval) = VariableAddress[r4] : -# 516| mu516_2(Rect) = Uninitialized[r4] : &:r516_1 -# 516| r516_3(glval) = FieldAddress[topLeft] : r516_1 -# 516| r516_4(glval) = FieldAddress[x] : r516_3 -# 516| r516_5(glval) = VariableAddress[x] : -# 516| r516_6(int) = Load : &:r516_5, m512_5 -# 516| mu516_7(int) = Store : &:r516_4, r516_6 -# 516| r516_8(glval) = FieldAddress[y] : r516_3 -# 516| r516_9(int) = Constant[0] : -# 516| mu516_10(int) = Store : &:r516_8, r516_9 -# 516| r516_11(glval) = FieldAddress[bottomRight] : r516_1 -# 516| r516_12(glval) = FieldAddress[x] : r516_11 -# 516| r516_13(glval) = VariableAddress[x] : -# 516| r516_14(int) = Load : &:r516_13, m512_5 -# 516| mu516_15(int) = Store : &:r516_12, r516_14 -# 516| r516_16(glval) = FieldAddress[y] : r516_11 -# 516| r516_17(int) = Constant[0] : -# 516| mu516_18(int) = Store : &:r516_16, r516_17 -# 517| v517_1(void) = NoOp : -# 512| v512_8(void) = ReturnVoid : -# 512| v512_9(void) = UnmodeledUse : mu* -# 512| v512_10(void) = AliasedUse : ~mu512_3 -# 512| v512_11(void) = ExitFunction : - -# 519| void ArrayInit(int, float) -# 519| Block 0 -# 519| v519_1(void) = EnterFunction : -# 519| mu519_2(unknown) = AliasedDefinition : -# 519| mu519_3(unknown) = UnmodeledDefinition : -# 519| r519_4(glval) = VariableAddress[x] : -# 519| m519_5(int) = InitializeParameter[x] : &:r519_4 -# 519| r519_6(glval) = VariableAddress[f] : -# 519| m519_7(float) = InitializeParameter[f] : &:r519_6 -# 520| r520_1(glval) = VariableAddress[a1] : -# 520| mu520_2(int[3]) = Uninitialized[a1] : &:r520_1 -# 520| r520_3(int) = Constant[0] : -# 520| r520_4(glval) = PointerAdd[4] : r520_1, r520_3 -# 520| r520_5(unknown[12]) = Constant[0] : -# 520| mu520_6(unknown[12]) = Store : &:r520_4, r520_5 -# 521| r521_1(glval) = VariableAddress[a2] : -# 521| mu521_2(int[3]) = Uninitialized[a2] : &:r521_1 -# 521| r521_3(int) = Constant[0] : -# 521| r521_4(glval) = PointerAdd[4] : r521_1, r521_3 -# 521| r521_5(glval) = VariableAddress[x] : -# 521| r521_6(int) = Load : &:r521_5, m519_5 -# 521| mu521_7(int) = Store : &:r521_4, r521_6 -# 521| r521_8(int) = Constant[1] : -# 521| r521_9(glval) = PointerAdd[4] : r521_1, r521_8 -# 521| r521_10(glval) = VariableAddress[f] : -# 521| r521_11(float) = Load : &:r521_10, m519_7 -# 521| r521_12(int) = Convert : r521_11 -# 521| mu521_13(int) = Store : &:r521_9, r521_12 -# 521| r521_14(int) = Constant[2] : -# 521| r521_15(glval) = PointerAdd[4] : r521_1, r521_14 -# 521| r521_16(int) = Constant[0] : -# 521| mu521_17(int) = Store : &:r521_15, r521_16 -# 522| r522_1(glval) = VariableAddress[a3] : -# 522| mu522_2(int[3]) = Uninitialized[a3] : &:r522_1 -# 522| r522_3(int) = Constant[0] : -# 522| r522_4(glval) = PointerAdd[4] : r522_1, r522_3 -# 522| r522_5(glval) = VariableAddress[x] : -# 522| r522_6(int) = Load : &:r522_5, m519_5 -# 522| mu522_7(int) = Store : &:r522_4, r522_6 -# 522| r522_8(int) = Constant[1] : -# 522| r522_9(glval) = PointerAdd[4] : r522_1, r522_8 -# 522| r522_10(unknown[8]) = Constant[0] : -# 522| mu522_11(unknown[8]) = Store : &:r522_9, r522_10 -# 523| v523_1(void) = NoOp : -# 519| v519_8(void) = ReturnVoid : -# 519| v519_9(void) = UnmodeledUse : mu* -# 519| v519_10(void) = AliasedUse : ~mu519_3 -# 519| v519_11(void) = ExitFunction : - -# 530| void UnionInit(int, float) -# 530| Block 0 -# 530| v530_1(void) = EnterFunction : -# 530| mu530_2(unknown) = AliasedDefinition : -# 530| mu530_3(unknown) = UnmodeledDefinition : -# 530| r530_4(glval) = VariableAddress[x] : -# 530| m530_5(int) = InitializeParameter[x] : &:r530_4 -# 530| r530_6(glval) = VariableAddress[f] : -# 530| m530_7(float) = InitializeParameter[f] : &:r530_6 -# 531| r531_1(glval) = VariableAddress[u1] : -# 531| mu531_2(U) = Uninitialized[u1] : &:r531_1 -# 531| r531_3(glval) = FieldAddress[d] : r531_1 -# 531| r531_4(glval) = VariableAddress[f] : -# 531| r531_5(float) = Load : &:r531_4, m530_7 -# 531| r531_6(double) = Convert : r531_5 -# 531| mu531_7(double) = Store : &:r531_3, r531_6 -# 533| v533_1(void) = NoOp : -# 530| v530_8(void) = ReturnVoid : -# 530| v530_9(void) = UnmodeledUse : mu* -# 530| v530_10(void) = AliasedUse : ~mu530_3 -# 530| v530_11(void) = ExitFunction : - -# 535| void EarlyReturn(int, int) -# 535| Block 0 -# 535| v535_1(void) = EnterFunction : -# 535| mu535_2(unknown) = AliasedDefinition : -# 535| mu535_3(unknown) = UnmodeledDefinition : -# 535| r535_4(glval) = VariableAddress[x] : -# 535| m535_5(int) = InitializeParameter[x] : &:r535_4 -# 535| r535_6(glval) = VariableAddress[y] : -# 535| m535_7(int) = InitializeParameter[y] : &:r535_6 -# 536| r536_1(glval) = VariableAddress[x] : -# 536| r536_2(int) = Load : &:r536_1, m535_5 -# 536| r536_3(glval) = VariableAddress[y] : -# 536| r536_4(int) = Load : &:r536_3, m535_7 -# 536| r536_5(bool) = CompareLT : r536_2, r536_4 -# 536| v536_6(void) = ConditionalBranch : r536_5 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 535| Block 1 -# 535| v535_8(void) = ReturnVoid : -# 535| v535_9(void) = UnmodeledUse : mu* -# 535| v535_10(void) = AliasedUse : ~mu535_3 -# 535| v535_11(void) = ExitFunction : - -# 537| Block 2 -# 537| v537_1(void) = NoOp : -#-----| Goto -> Block 1 - -# 540| Block 3 -# 540| r540_1(glval) = VariableAddress[x] : -# 540| r540_2(int) = Load : &:r540_1, m535_5 -# 540| r540_3(glval) = VariableAddress[y] : -# 540| m540_4(int) = Store : &:r540_3, r540_2 -# 541| v541_1(void) = NoOp : -#-----| Goto -> Block 1 - -# 543| int EarlyReturnValue(int, int) -# 543| Block 0 -# 543| v543_1(void) = EnterFunction : -# 543| mu543_2(unknown) = AliasedDefinition : -# 543| mu543_3(unknown) = UnmodeledDefinition : -# 543| r543_4(glval) = VariableAddress[x] : -# 543| m543_5(int) = InitializeParameter[x] : &:r543_4 -# 543| r543_6(glval) = VariableAddress[y] : -# 543| m543_7(int) = InitializeParameter[y] : &:r543_6 -# 544| r544_1(glval) = VariableAddress[x] : -# 544| r544_2(int) = Load : &:r544_1, m543_5 -# 544| r544_3(glval) = VariableAddress[y] : -# 544| r544_4(int) = Load : &:r544_3, m543_7 -# 544| r544_5(bool) = CompareLT : r544_2, r544_4 -# 544| v544_6(void) = ConditionalBranch : r544_5 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 543| Block 1 -# 543| m543_8(int) = Phi : from 2:m545_4, from 3:m548_7 -# 543| r543_9(glval) = VariableAddress[#return] : -# 543| v543_10(void) = ReturnValue : &:r543_9, m543_8 -# 543| v543_11(void) = UnmodeledUse : mu* -# 543| v543_12(void) = AliasedUse : ~mu543_3 -# 543| v543_13(void) = ExitFunction : - -# 545| Block 2 -# 545| r545_1(glval) = VariableAddress[#return] : -# 545| r545_2(glval) = VariableAddress[x] : -# 545| r545_3(int) = Load : &:r545_2, m543_5 -# 545| m545_4(int) = Store : &:r545_1, r545_3 -#-----| Goto -> Block 1 - -# 548| Block 3 -# 548| r548_1(glval) = VariableAddress[#return] : -# 548| r548_2(glval) = VariableAddress[x] : -# 548| r548_3(int) = Load : &:r548_2, m543_5 -# 548| r548_4(glval) = VariableAddress[y] : -# 548| r548_5(int) = Load : &:r548_4, m543_7 -# 548| r548_6(int) = Add : r548_3, r548_5 -# 548| m548_7(int) = Store : &:r548_1, r548_6 -#-----| Goto -> Block 1 - -# 551| int CallViaFuncPtr(int(*)(int)) -# 551| Block 0 -# 551| v551_1(void) = EnterFunction : -# 551| mu551_2(unknown) = AliasedDefinition : -# 551| mu551_3(unknown) = UnmodeledDefinition : -# 551| r551_4(glval<..(*)(..)>) = VariableAddress[pfn] : -# 551| m551_5(..(*)(..)) = InitializeParameter[pfn] : &:r551_4 -# 552| r552_1(glval) = VariableAddress[#return] : -# 552| r552_2(glval<..(*)(..)>) = VariableAddress[pfn] : -# 552| r552_3(..(*)(..)) = Load : &:r552_2, m551_5 -# 552| r552_4(int) = Constant[5] : -# 552| r552_5(int) = Call : func:r552_3, 0:r552_4 -# 552| mu552_6(unknown) = ^CallSideEffect : ~mu551_3 -# 552| m552_7(int) = Store : &:r552_1, r552_5 -# 551| r551_6(glval) = VariableAddress[#return] : -# 551| v551_7(void) = ReturnValue : &:r551_6, m552_7 -# 551| v551_8(void) = UnmodeledUse : mu* -# 551| v551_9(void) = AliasedUse : ~mu551_3 -# 551| v551_10(void) = ExitFunction : - -# 560| int EnumSwitch(E) -# 560| Block 0 -# 560| v560_1(void) = EnterFunction : -# 560| mu560_2(unknown) = AliasedDefinition : -# 560| mu560_3(unknown) = UnmodeledDefinition : -# 560| r560_4(glval) = VariableAddress[e] : -# 560| m560_5(E) = InitializeParameter[e] : &:r560_4 -# 561| r561_1(glval) = VariableAddress[e] : -# 561| r561_2(E) = Load : &:r561_1, m560_5 -# 561| r561_3(int) = Convert : r561_2 -# 561| v561_4(void) = Switch : r561_3 -#-----| Case[0] -> Block 4 -#-----| Case[1] -> Block 2 -#-----| Default -> Block 3 - -# 560| Block 1 -# 560| m560_6(int) = Phi : from 2:m565_3, from 3:m567_3, from 4:m563_3 -# 560| r560_7(glval) = VariableAddress[#return] : -# 560| v560_8(void) = ReturnValue : &:r560_7, m560_6 -# 560| v560_9(void) = UnmodeledUse : mu* -# 560| v560_10(void) = AliasedUse : ~mu560_3 -# 560| v560_11(void) = ExitFunction : - -# 564| Block 2 -# 564| v564_1(void) = NoOp : -# 565| r565_1(glval) = VariableAddress[#return] : -# 565| r565_2(int) = Constant[1] : -# 565| m565_3(int) = Store : &:r565_1, r565_2 -#-----| Goto -> Block 1 - -# 566| Block 3 -# 566| v566_1(void) = NoOp : -# 567| r567_1(glval) = VariableAddress[#return] : -# 567| r567_2(int) = Constant[-1] : -# 567| m567_3(int) = Store : &:r567_1, r567_2 -#-----| Goto -> Block 1 - -# 562| Block 4 -# 562| v562_1(void) = NoOp : -# 563| r563_1(glval) = VariableAddress[#return] : -# 563| r563_2(int) = Constant[0] : -# 563| m563_3(int) = Store : &:r563_1, r563_2 -#-----| Goto -> Block 1 - -# 571| void InitArray() -# 571| Block 0 -# 571| v571_1(void) = EnterFunction : -# 571| mu571_2(unknown) = AliasedDefinition : -# 571| mu571_3(unknown) = UnmodeledDefinition : -# 572| r572_1(glval) = VariableAddress[a_pad] : -# 572| r572_2(glval) = StringConstant[""] : -# 572| r572_3(char[32]) = Load : &:r572_2, ~mu571_3 -# 572| m572_4(char[32]) = Store : &:r572_1, r572_3 -# 573| r573_1(glval) = VariableAddress[a_nopad] : -# 573| r573_2(glval) = StringConstant["foo"] : -# 573| r573_3(char[4]) = Load : &:r573_2, ~mu571_3 -# 573| m573_4(char[4]) = Store : &:r573_1, r573_3 -# 574| r574_1(glval) = VariableAddress[a_infer] : -# 574| r574_2(glval) = StringConstant["blah"] : -# 574| r574_3(char[5]) = Load : &:r574_2, ~mu571_3 -# 574| m574_4(char[5]) = Store : &:r574_1, r574_3 -# 575| r575_1(glval) = VariableAddress[b] : -# 575| m575_2(char[2]) = Uninitialized[b] : &:r575_1 -# 576| r576_1(glval) = VariableAddress[c] : -# 576| mu576_2(char[2]) = Uninitialized[c] : &:r576_1 -# 576| r576_3(int) = Constant[0] : -# 576| r576_4(glval) = PointerAdd[1] : r576_1, r576_3 -# 576| r576_5(unknown[2]) = Constant[0] : -# 576| mu576_6(unknown[2]) = Store : &:r576_4, r576_5 -# 577| r577_1(glval) = VariableAddress[d] : -# 577| mu577_2(char[2]) = Uninitialized[d] : &:r577_1 -# 577| r577_3(int) = Constant[0] : -# 577| r577_4(glval) = PointerAdd[1] : r577_1, r577_3 -# 577| r577_5(char) = Constant[0] : -# 577| mu577_6(char) = Store : &:r577_4, r577_5 -# 577| r577_7(int) = Constant[1] : -# 577| r577_8(glval) = PointerAdd[1] : r577_1, r577_7 -# 577| r577_9(char) = Constant[0] : -# 577| mu577_10(char) = Store : &:r577_8, r577_9 -# 578| r578_1(glval) = VariableAddress[e] : -# 578| mu578_2(char[2]) = Uninitialized[e] : &:r578_1 -# 578| r578_3(int) = Constant[0] : -# 578| r578_4(glval) = PointerAdd[1] : r578_1, r578_3 -# 578| r578_5(char) = Constant[0] : -# 578| mu578_6(char) = Store : &:r578_4, r578_5 -# 578| r578_7(int) = Constant[1] : -# 578| r578_8(glval) = PointerAdd[1] : r578_1, r578_7 -# 578| r578_9(char) = Constant[1] : -# 578| mu578_10(char) = Store : &:r578_8, r578_9 -# 579| r579_1(glval) = VariableAddress[f] : -# 579| mu579_2(char[3]) = Uninitialized[f] : &:r579_1 -# 579| r579_3(int) = Constant[0] : -# 579| r579_4(glval) = PointerAdd[1] : r579_1, r579_3 -# 579| r579_5(char) = Constant[0] : -# 579| mu579_6(char) = Store : &:r579_4, r579_5 -# 579| r579_7(int) = Constant[1] : -# 579| r579_8(glval) = PointerAdd[1] : r579_1, r579_7 -# 579| r579_9(unknown[2]) = Constant[0] : -# 579| mu579_10(unknown[2]) = Store : &:r579_8, r579_9 -# 580| v580_1(void) = NoOp : -# 571| v571_4(void) = ReturnVoid : -# 571| v571_5(void) = UnmodeledUse : mu* -# 571| v571_6(void) = AliasedUse : ~mu571_3 -# 571| v571_7(void) = ExitFunction : - -# 584| void VarArgs() -# 584| Block 0 -# 584| v584_1(void) = EnterFunction : -# 584| mu584_2(unknown) = AliasedDefinition : -# 584| mu584_3(unknown) = UnmodeledDefinition : -# 585| r585_1(glval) = FunctionAddress[VarArgFunction] : -# 585| r585_2(glval) = StringConstant["%d %s"] : -# 585| r585_3(char *) = Convert : r585_2 -# 585| r585_4(int) = Constant[1] : -# 585| r585_5(glval) = StringConstant["string"] : -# 585| r585_6(char *) = Convert : r585_5 -# 585| v585_7(void) = Call : func:r585_1, 0:r585_3, 1:r585_4, 2:r585_6 -# 585| mu585_8(unknown) = ^CallSideEffect : ~mu584_3 -# 585| v585_9(void) = ^BufferReadSideEffect[0] : &:r585_3, ~mu584_3 -# 585| v585_10(void) = ^BufferReadSideEffect[2] : &:r585_6, ~mu584_3 -# 585| mu585_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r585_3 -# 585| mu585_12(unknown) = ^BufferMayWriteSideEffect[2] : &:r585_6 -# 586| v586_1(void) = NoOp : -# 584| v584_4(void) = ReturnVoid : -# 584| v584_5(void) = UnmodeledUse : mu* -# 584| v584_6(void) = AliasedUse : ~mu584_3 -# 584| v584_7(void) = ExitFunction : - -# 590| void SetFuncPtr() -# 590| Block 0 -# 590| v590_1(void) = EnterFunction : -# 590| mu590_2(unknown) = AliasedDefinition : -# 590| mu590_3(unknown) = UnmodeledDefinition : -# 591| r591_1(glval<..(*)(..)>) = VariableAddress[pfn] : -# 591| r591_2(..(*)(..)) = FunctionAddress[FuncPtrTarget] : -# 591| m591_3(..(*)(..)) = Store : &:r591_1, r591_2 -# 592| r592_1(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 592| r592_2(..(*)(..)) = CopyValue : r592_1 -# 592| r592_3(glval<..(*)(..)>) = VariableAddress[pfn] : -# 592| m592_4(..(*)(..)) = Store : &:r592_3, r592_2 -# 593| r593_1(..(*)(..)) = FunctionAddress[FuncPtrTarget] : -# 593| r593_2(..(*)(..)) = CopyValue : r593_1 -# 593| r593_3(glval<..(*)(..)>) = VariableAddress[pfn] : -# 593| m593_4(..(*)(..)) = Store : &:r593_3, r593_2 -# 594| r594_1(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 594| r594_2(..(*)(..)) = CopyValue : r594_1 -# 594| r594_3(..(*)(..)) = CopyValue : r594_2 -# 594| r594_4(..(*)(..)) = CopyValue : r594_3 -# 594| r594_5(..(*)(..)) = CopyValue : r594_4 -# 594| r594_6(glval<..(*)(..)>) = VariableAddress[pfn] : -# 594| m594_7(..(*)(..)) = Store : &:r594_6, r594_5 -# 595| v595_1(void) = NoOp : -# 590| v590_4(void) = ReturnVoid : -# 590| v590_5(void) = UnmodeledUse : mu* -# 590| v590_6(void) = AliasedUse : ~mu590_3 -# 590| v590_7(void) = ExitFunction : - -# 615| void DeclareObject() -# 615| Block 0 -# 615| v615_1(void) = EnterFunction : -# 615| mu615_2(unknown) = AliasedDefinition : -# 615| mu615_3(unknown) = UnmodeledDefinition : -# 616| r616_1(glval) = VariableAddress[s1] : -# 616| m616_2(String) = Uninitialized[s1] : &:r616_1 -# 616| r616_3(glval) = FunctionAddress[String] : -# 616| v616_4(void) = Call : func:r616_3, this:r616_1 -# 616| mu616_5(unknown) = ^CallSideEffect : ~mu615_3 -# 616| m616_6(String) = ^IndirectMayWriteSideEffect[-1] : &:r616_1 -# 617| r617_1(glval) = VariableAddress[s2] : -# 617| m617_2(String) = Uninitialized[s2] : &:r617_1 -# 617| r617_3(glval) = FunctionAddress[String] : -# 617| r617_4(glval) = StringConstant["hello"] : -# 617| r617_5(char *) = Convert : r617_4 -# 617| v617_6(void) = Call : func:r617_3, this:r617_1, 0:r617_5 -# 617| mu617_7(unknown) = ^CallSideEffect : ~mu615_3 -# 617| m617_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r617_1 -# 617| v617_9(void) = ^BufferReadSideEffect[0] : &:r617_5, ~mu615_3 -# 617| mu617_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r617_5 -# 618| r618_1(glval) = VariableAddress[s3] : -# 618| r618_2(glval) = FunctionAddress[ReturnObject] : -# 618| r618_3(String) = Call : func:r618_2 -# 618| mu618_4(unknown) = ^CallSideEffect : ~mu615_3 -# 618| m618_5(String) = Store : &:r618_1, r618_3 -# 619| r619_1(glval) = VariableAddress[s4] : -# 619| m619_2(String) = Uninitialized[s4] : &:r619_1 -# 619| r619_3(glval) = FunctionAddress[String] : -# 619| r619_4(glval) = StringConstant["test"] : -# 619| r619_5(char *) = Convert : r619_4 -# 619| v619_6(void) = Call : func:r619_3, this:r619_1, 0:r619_5 -# 619| mu619_7(unknown) = ^CallSideEffect : ~mu615_3 -# 619| m619_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r619_1 -# 619| v619_9(void) = ^BufferReadSideEffect[0] : &:r619_5, ~mu615_3 -# 619| mu619_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r619_5 -# 620| v620_1(void) = NoOp : -# 615| v615_4(void) = ReturnVoid : -# 615| v615_5(void) = UnmodeledUse : mu* -# 615| v615_6(void) = AliasedUse : ~mu615_3 -# 615| v615_7(void) = ExitFunction : - -# 622| void CallMethods(String&, String*, String) -# 622| Block 0 -# 622| v622_1(void) = EnterFunction : -# 622| mu622_2(unknown) = AliasedDefinition : -# 622| mu622_3(unknown) = UnmodeledDefinition : -# 622| r622_4(glval) = VariableAddress[r] : -# 622| m622_5(String &) = InitializeParameter[r] : &:r622_4 -# 622| r622_6(String &) = Load : &:r622_4, m622_5 -# 622| mu622_7(unknown) = InitializeIndirection[r] : &:r622_6 -# 622| r622_8(glval) = VariableAddress[p] : -# 622| m622_9(String *) = InitializeParameter[p] : &:r622_8 -# 622| r622_10(String *) = Load : &:r622_8, m622_9 -# 622| mu622_11(unknown) = InitializeIndirection[p] : &:r622_10 -# 622| r622_12(glval) = VariableAddress[s] : -# 622| mu622_13(String) = InitializeParameter[s] : &:r622_12 -# 623| r623_1(glval) = VariableAddress[r] : -# 623| r623_2(String &) = Load : &:r623_1, m622_5 -# 623| r623_3(glval) = CopyValue : r623_2 -# 623| r623_4(glval) = Convert : r623_3 -# 623| r623_5(glval) = FunctionAddress[c_str] : -# 623| r623_6(char *) = Call : func:r623_5, this:r623_4 -# 623| mu623_7(unknown) = ^CallSideEffect : ~mu622_3 -# 623| v623_8(void) = ^BufferReadSideEffect[-1] : &:r623_4, ~mu622_3 -# 623| mu623_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r623_4 -# 624| r624_1(glval) = VariableAddress[p] : -# 624| r624_2(String *) = Load : &:r624_1, m622_9 -# 624| r624_3(String *) = Convert : r624_2 -# 624| r624_4(glval) = FunctionAddress[c_str] : -# 624| r624_5(char *) = Call : func:r624_4, this:r624_3 -# 624| mu624_6(unknown) = ^CallSideEffect : ~mu622_3 -# 624| v624_7(void) = ^BufferReadSideEffect[-1] : &:r624_3, ~mu622_3 -# 624| mu624_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r624_3 -# 625| r625_1(glval) = VariableAddress[s] : -# 625| r625_2(glval) = Convert : r625_1 -# 625| r625_3(glval) = FunctionAddress[c_str] : -# 625| r625_4(char *) = Call : func:r625_3, this:r625_2 -# 625| mu625_5(unknown) = ^CallSideEffect : ~mu622_3 -# 625| v625_6(void) = ^BufferReadSideEffect[-1] : &:r625_2, ~mu622_3 -# 625| mu625_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r625_2 -# 626| v626_1(void) = NoOp : -# 622| v622_14(void) = ReturnIndirection : &:r622_6, ~mu622_3 -# 622| v622_15(void) = ReturnIndirection : &:r622_10, ~mu622_3 -# 622| v622_16(void) = ReturnVoid : -# 622| v622_17(void) = UnmodeledUse : mu* -# 622| v622_18(void) = AliasedUse : ~mu622_3 -# 622| v622_19(void) = ExitFunction : - -# 630| int C::StaticMemberFunction(int) -# 630| Block 0 -# 630| v630_1(void) = EnterFunction : -# 630| mu630_2(unknown) = AliasedDefinition : -# 630| mu630_3(unknown) = UnmodeledDefinition : -# 630| r630_4(glval) = VariableAddress[x] : -# 630| m630_5(int) = InitializeParameter[x] : &:r630_4 -# 631| r631_1(glval) = VariableAddress[#return] : -# 631| r631_2(glval) = VariableAddress[x] : -# 631| r631_3(int) = Load : &:r631_2, m630_5 -# 631| m631_4(int) = Store : &:r631_1, r631_3 -# 630| r630_6(glval) = VariableAddress[#return] : -# 630| v630_7(void) = ReturnValue : &:r630_6, m631_4 -# 630| v630_8(void) = UnmodeledUse : mu* -# 630| v630_9(void) = AliasedUse : ~mu630_3 -# 630| v630_10(void) = ExitFunction : - -# 634| int C::InstanceMemberFunction(int) -# 634| Block 0 -# 634| v634_1(void) = EnterFunction : -# 634| mu634_2(unknown) = AliasedDefinition : -# 634| mu634_3(unknown) = UnmodeledDefinition : -# 634| r634_4(glval) = InitializeThis : -# 634| r634_5(glval) = VariableAddress[x] : -# 634| m634_6(int) = InitializeParameter[x] : &:r634_5 -# 635| r635_1(glval) = VariableAddress[#return] : -# 635| r635_2(glval) = VariableAddress[x] : -# 635| r635_3(int) = Load : &:r635_2, m634_6 -# 635| m635_4(int) = Store : &:r635_1, r635_3 -# 634| r634_7(glval) = VariableAddress[#return] : -# 634| v634_8(void) = ReturnValue : &:r634_7, m635_4 -# 634| v634_9(void) = UnmodeledUse : mu* -# 634| v634_10(void) = AliasedUse : ~mu634_3 -# 634| v634_11(void) = ExitFunction : - -# 638| int C::VirtualMemberFunction(int) -# 638| Block 0 -# 638| v638_1(void) = EnterFunction : -# 638| mu638_2(unknown) = AliasedDefinition : -# 638| mu638_3(unknown) = UnmodeledDefinition : -# 638| r638_4(glval) = InitializeThis : -# 638| r638_5(glval) = VariableAddress[x] : -# 638| m638_6(int) = InitializeParameter[x] : &:r638_5 -# 639| r639_1(glval) = VariableAddress[#return] : -# 639| r639_2(glval) = VariableAddress[x] : -# 639| r639_3(int) = Load : &:r639_2, m638_6 -# 639| m639_4(int) = Store : &:r639_1, r639_3 -# 638| r638_7(glval) = VariableAddress[#return] : -# 638| v638_8(void) = ReturnValue : &:r638_7, m639_4 -# 638| v638_9(void) = UnmodeledUse : mu* -# 638| v638_10(void) = AliasedUse : ~mu638_3 -# 638| v638_11(void) = ExitFunction : - -# 642| void C::FieldAccess() -# 642| Block 0 -# 642| v642_1(void) = EnterFunction : -# 642| mu642_2(unknown) = AliasedDefinition : -# 642| mu642_3(unknown) = UnmodeledDefinition : -# 642| r642_4(glval) = InitializeThis : -# 643| r643_1(int) = Constant[0] : -# 643| r643_2(C *) = CopyValue : r642_4 -# 643| r643_3(glval) = FieldAddress[m_a] : r643_2 -# 643| mu643_4(int) = Store : &:r643_3, r643_1 -# 644| r644_1(int) = Constant[1] : -# 644| r644_2(C *) = CopyValue : r642_4 -# 644| r644_3(glval) = CopyValue : r644_2 -# 644| r644_4(glval) = FieldAddress[m_a] : r644_3 -# 644| mu644_5(int) = Store : &:r644_4, r644_1 -# 645| r645_1(int) = Constant[2] : -#-----| r0_1(C *) = CopyValue : r642_4 -# 645| r645_2(glval) = FieldAddress[m_a] : r0_1 -# 645| mu645_3(int) = Store : &:r645_2, r645_1 -# 646| r646_1(glval) = VariableAddress[x] : -# 646| m646_2(int) = Uninitialized[x] : &:r646_1 -# 647| r647_1(C *) = CopyValue : r642_4 -# 647| r647_2(glval) = FieldAddress[m_a] : r647_1 -# 647| r647_3(int) = Load : &:r647_2, ~mu642_3 -# 647| r647_4(glval) = VariableAddress[x] : -# 647| m647_5(int) = Store : &:r647_4, r647_3 -# 648| r648_1(C *) = CopyValue : r642_4 -# 648| r648_2(glval) = CopyValue : r648_1 -# 648| r648_3(glval) = FieldAddress[m_a] : r648_2 -# 648| r648_4(int) = Load : &:r648_3, ~mu642_3 -# 648| r648_5(glval) = VariableAddress[x] : -# 648| m648_6(int) = Store : &:r648_5, r648_4 -#-----| r0_2(C *) = CopyValue : r642_4 -# 649| r649_1(glval) = FieldAddress[m_a] : r0_2 -# 649| r649_2(int) = Load : &:r649_1, ~mu642_3 -# 649| r649_3(glval) = VariableAddress[x] : -# 649| m649_4(int) = Store : &:r649_3, r649_2 -# 650| v650_1(void) = NoOp : -# 642| v642_5(void) = ReturnVoid : -# 642| v642_6(void) = UnmodeledUse : mu* -# 642| v642_7(void) = AliasedUse : ~mu642_3 -# 642| v642_8(void) = ExitFunction : - -# 652| void C::MethodCalls() -# 652| Block 0 -# 652| v652_1(void) = EnterFunction : -# 652| mu652_2(unknown) = AliasedDefinition : -# 652| mu652_3(unknown) = UnmodeledDefinition : -# 652| r652_4(glval) = InitializeThis : -# 653| r653_1(C *) = CopyValue : r652_4 -# 653| r653_2(glval) = FunctionAddress[InstanceMemberFunction] : -# 653| r653_3(int) = Constant[0] : -# 653| r653_4(int) = Call : func:r653_2, this:r653_1, 0:r653_3 -# 653| mu653_5(unknown) = ^CallSideEffect : ~mu652_3 -# 653| v653_6(void) = ^BufferReadSideEffect[-1] : &:r653_1, ~mu652_3 -# 653| mu653_7(C) = ^IndirectMayWriteSideEffect[-1] : &:r653_1 -# 654| r654_1(C *) = CopyValue : r652_4 -# 654| r654_2(glval) = CopyValue : r654_1 -# 654| r654_3(glval) = FunctionAddress[InstanceMemberFunction] : -# 654| r654_4(int) = Constant[1] : -# 654| r654_5(int) = Call : func:r654_3, this:r654_2, 0:r654_4 -# 654| mu654_6(unknown) = ^CallSideEffect : ~mu652_3 -# 654| v654_7(void) = ^BufferReadSideEffect[-1] : &:r654_2, ~mu652_3 -# 654| mu654_8(C) = ^IndirectMayWriteSideEffect[-1] : &:r654_2 -#-----| r0_1(C *) = CopyValue : r652_4 -# 655| r655_1(glval) = FunctionAddress[InstanceMemberFunction] : -# 655| r655_2(int) = Constant[2] : -# 655| r655_3(int) = Call : func:r655_1, this:r0_1, 0:r655_2 -# 655| mu655_4(unknown) = ^CallSideEffect : ~mu652_3 -#-----| v0_2(void) = ^BufferReadSideEffect[-1] : &:r0_1, ~mu652_3 -#-----| mu0_3(C) = ^IndirectMayWriteSideEffect[-1] : &:r0_1 -# 656| v656_1(void) = NoOp : -# 652| v652_5(void) = ReturnVoid : -# 652| v652_6(void) = UnmodeledUse : mu* -# 652| v652_7(void) = AliasedUse : ~mu652_3 -# 652| v652_8(void) = ExitFunction : - -# 658| void C::C() -# 658| Block 0 -# 658| v658_1(void) = EnterFunction : -# 658| mu658_2(unknown) = AliasedDefinition : -# 658| mu658_3(unknown) = UnmodeledDefinition : -# 658| r658_4(glval) = InitializeThis : -# 659| r659_1(glval) = FieldAddress[m_a] : r658_4 -# 659| r659_2(int) = Constant[1] : -# 659| mu659_3(int) = Store : &:r659_1, r659_2 -# 663| r663_1(glval) = FieldAddress[m_b] : r658_4 -# 663| r663_2(glval) = FunctionAddress[String] : -# 663| v663_3(void) = Call : func:r663_2, this:r663_1 -# 663| mu663_4(unknown) = ^CallSideEffect : ~mu658_3 -# 663| mu663_5(String) = ^IndirectMayWriteSideEffect[-1] : &:r663_1 -# 660| r660_1(glval) = FieldAddress[m_c] : r658_4 -# 660| r660_2(char) = Constant[3] : -# 660| mu660_3(char) = Store : &:r660_1, r660_2 -# 661| r661_1(glval) = FieldAddress[m_e] : r658_4 -# 661| r661_2(void *) = Constant[0] : -# 661| mu661_3(void *) = Store : &:r661_1, r661_2 -# 662| r662_1(glval) = FieldAddress[m_f] : r658_4 -# 662| r662_2(glval) = FunctionAddress[String] : -# 662| r662_3(glval) = StringConstant["test"] : -# 662| r662_4(char *) = Convert : r662_3 -# 662| v662_5(void) = Call : func:r662_2, this:r662_1, 0:r662_4 -# 662| mu662_6(unknown) = ^CallSideEffect : ~mu658_3 -# 662| mu662_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r662_1 -# 662| v662_8(void) = ^BufferReadSideEffect[0] : &:r662_4, ~mu658_3 -# 662| mu662_9(unknown) = ^BufferMayWriteSideEffect[0] : &:r662_4 -# 664| v664_1(void) = NoOp : -# 658| v658_5(void) = ReturnVoid : -# 658| v658_6(void) = UnmodeledUse : mu* -# 658| v658_7(void) = AliasedUse : ~mu658_3 -# 658| v658_8(void) = ExitFunction : - -# 675| int DerefReference(int&) -# 675| Block 0 -# 675| v675_1(void) = EnterFunction : -# 675| mu675_2(unknown) = AliasedDefinition : -# 675| mu675_3(unknown) = UnmodeledDefinition : -# 675| r675_4(glval) = VariableAddress[r] : -# 675| m675_5(int &) = InitializeParameter[r] : &:r675_4 -# 675| r675_6(int &) = Load : &:r675_4, m675_5 -# 675| mu675_7(unknown) = InitializeIndirection[r] : &:r675_6 -# 676| r676_1(glval) = VariableAddress[#return] : -# 676| r676_2(glval) = VariableAddress[r] : -# 676| r676_3(int &) = Load : &:r676_2, m675_5 -# 676| r676_4(int) = Load : &:r676_3, ~mu675_3 -# 676| m676_5(int) = Store : &:r676_1, r676_4 -# 675| v675_8(void) = ReturnIndirection : &:r675_6, ~mu675_3 -# 675| r675_9(glval) = VariableAddress[#return] : -# 675| v675_10(void) = ReturnValue : &:r675_9, m676_5 -# 675| v675_11(void) = UnmodeledUse : mu* -# 675| v675_12(void) = AliasedUse : ~mu675_3 -# 675| v675_13(void) = ExitFunction : - -# 679| int& TakeReference() -# 679| Block 0 -# 679| v679_1(void) = EnterFunction : -# 679| mu679_2(unknown) = AliasedDefinition : -# 679| mu679_3(unknown) = UnmodeledDefinition : -# 680| r680_1(glval) = VariableAddress[#return] : -# 680| r680_2(glval) = VariableAddress[g] : -# 680| r680_3(int &) = CopyValue : r680_2 -# 680| m680_4(int &) = Store : &:r680_1, r680_3 -# 679| r679_4(glval) = VariableAddress[#return] : -# 679| v679_5(void) = ReturnValue : &:r679_4, m680_4 -# 679| v679_6(void) = UnmodeledUse : mu* -# 679| v679_7(void) = AliasedUse : ~mu679_3 -# 679| v679_8(void) = ExitFunction : - -# 685| void InitReference(int) -# 685| Block 0 -# 685| v685_1(void) = EnterFunction : -# 685| mu685_2(unknown) = AliasedDefinition : -# 685| mu685_3(unknown) = UnmodeledDefinition : -# 685| r685_4(glval) = VariableAddress[x] : -# 685| m685_5(int) = InitializeParameter[x] : &:r685_4 -# 686| r686_1(glval) = VariableAddress[r] : -# 686| r686_2(glval) = VariableAddress[x] : -# 686| r686_3(int &) = CopyValue : r686_2 -# 686| m686_4(int &) = Store : &:r686_1, r686_3 -# 687| r687_1(glval) = VariableAddress[r2] : -# 687| r687_2(glval) = VariableAddress[r] : -# 687| r687_3(int &) = Load : &:r687_2, m686_4 -# 687| r687_4(glval) = CopyValue : r687_3 -# 687| r687_5(int &) = CopyValue : r687_4 -# 687| m687_6(int &) = Store : &:r687_1, r687_5 -# 688| r688_1(glval) = VariableAddress[r3] : -# 688| r688_2(glval) = FunctionAddress[ReturnReference] : -# 688| r688_3(String &) = Call : func:r688_2 -# 688| mu688_4(unknown) = ^CallSideEffect : ~mu685_3 -# 688| r688_5(glval) = CopyValue : r688_3 -# 688| r688_6(glval) = Convert : r688_5 -# 688| r688_7(String &) = CopyValue : r688_6 -# 688| m688_8(String &) = Store : &:r688_1, r688_7 -# 689| v689_1(void) = NoOp : -# 685| v685_6(void) = ReturnVoid : -# 685| v685_7(void) = UnmodeledUse : mu* -# 685| v685_8(void) = AliasedUse : ~mu685_3 -# 685| v685_9(void) = ExitFunction : - -# 691| void ArrayReferences() -# 691| Block 0 -# 691| v691_1(void) = EnterFunction : -# 691| mu691_2(unknown) = AliasedDefinition : -# 691| mu691_3(unknown) = UnmodeledDefinition : -# 692| r692_1(glval) = VariableAddress[a] : -# 692| m692_2(int[10]) = Uninitialized[a] : &:r692_1 -# 693| r693_1(glval) = VariableAddress[ra] : -# 693| r693_2(glval) = VariableAddress[a] : -# 693| r693_3(int(&)[10]) = CopyValue : r693_2 -# 693| m693_4(int(&)[10]) = Store : &:r693_1, r693_3 -# 694| r694_1(glval) = VariableAddress[x] : -# 694| r694_2(glval) = VariableAddress[ra] : -# 694| r694_3(int(&)[10]) = Load : &:r694_2, m693_4 -# 694| r694_4(glval) = CopyValue : r694_3 -# 694| r694_5(int *) = Convert : r694_4 -# 694| r694_6(int) = Constant[5] : -# 694| r694_7(glval) = PointerAdd[4] : r694_5, r694_6 -# 694| r694_8(int) = Load : &:r694_7, ~mu691_3 -# 694| m694_9(int) = Store : &:r694_1, r694_8 -# 695| v695_1(void) = NoOp : -# 691| v691_4(void) = ReturnVoid : -# 691| v691_5(void) = UnmodeledUse : mu* -# 691| v691_6(void) = AliasedUse : ~mu691_3 -# 691| v691_7(void) = ExitFunction : - -# 697| void FunctionReferences() -# 697| Block 0 -# 697| v697_1(void) = EnterFunction : -# 697| mu697_2(unknown) = AliasedDefinition : -# 697| mu697_3(unknown) = UnmodeledDefinition : -# 698| r698_1(glval<..(&)(..)>) = VariableAddress[rfn] : -# 698| r698_2(glval<..()(..)>) = FunctionAddress[FuncPtrTarget] : -# 698| r698_3(..(&)(..)) = CopyValue : r698_2 -# 698| m698_4(..(&)(..)) = Store : &:r698_1, r698_3 -# 699| r699_1(glval<..(*)(..)>) = VariableAddress[pfn] : -# 699| r699_2(glval<..(&)(..)>) = VariableAddress[rfn] : -# 699| r699_3(..(&)(..)) = Load : &:r699_2, m698_4 -# 699| r699_4(..(*)(..)) = CopyValue : r699_3 -# 699| m699_5(..(*)(..)) = Store : &:r699_1, r699_4 -# 700| r700_1(glval<..(&)(..)>) = VariableAddress[rfn] : -# 700| r700_2(..(&)(..)) = Load : &:r700_1, m698_4 -# 700| r700_3(..(*)(..)) = CopyValue : r700_2 -# 700| r700_4(int) = Constant[5] : -# 700| r700_5(int) = Call : func:r700_3, 0:r700_4 -# 700| mu700_6(unknown) = ^CallSideEffect : ~mu697_3 -# 701| v701_1(void) = NoOp : -# 697| v697_4(void) = ReturnVoid : -# 697| v697_5(void) = UnmodeledUse : mu* -# 697| v697_6(void) = AliasedUse : ~mu697_3 -# 697| v697_7(void) = ExitFunction : - -# 704| int min(int, int) -# 704| Block 0 -# 704| v704_1(void) = EnterFunction : -# 704| mu704_2(unknown) = AliasedDefinition : -# 704| mu704_3(unknown) = UnmodeledDefinition : -# 704| r704_4(glval) = VariableAddress[x] : -# 704| m704_5(int) = InitializeParameter[x] : &:r704_4 -# 704| r704_6(glval) = VariableAddress[y] : -# 704| m704_7(int) = InitializeParameter[y] : &:r704_6 -# 705| r705_1(glval) = VariableAddress[#return] : -# 705| r705_2(glval) = VariableAddress[x] : -# 705| r705_3(int) = Load : &:r705_2, m704_5 -# 705| r705_4(glval) = VariableAddress[y] : -# 705| r705_5(int) = Load : &:r705_4, m704_7 -# 705| r705_6(bool) = CompareLT : r705_3, r705_5 -# 705| v705_7(void) = ConditionalBranch : r705_6 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 705| Block 1 -# 705| r705_8(glval) = VariableAddress[x] : -# 705| r705_9(int) = Load : &:r705_8, m704_5 -# 705| r705_10(glval) = VariableAddress[#temp705:10] : -# 705| m705_11(int) = Store : &:r705_10, r705_9 -#-----| Goto -> Block 3 - -# 705| Block 2 -# 705| r705_12(glval) = VariableAddress[y] : -# 705| r705_13(int) = Load : &:r705_12, m704_7 -# 705| r705_14(glval) = VariableAddress[#temp705:10] : -# 705| m705_15(int) = Store : &:r705_14, r705_13 -#-----| Goto -> Block 3 - -# 705| Block 3 -# 705| m705_16(int) = Phi : from 1:m705_11, from 2:m705_15 -# 705| r705_17(glval) = VariableAddress[#temp705:10] : -# 705| r705_18(int) = Load : &:r705_17, m705_16 -# 705| m705_19(int) = Store : &:r705_1, r705_18 -# 704| r704_8(glval) = VariableAddress[#return] : -# 704| v704_9(void) = ReturnValue : &:r704_8, m705_19 -# 704| v704_10(void) = UnmodeledUse : mu* -# 704| v704_11(void) = AliasedUse : ~mu704_3 -# 704| v704_12(void) = ExitFunction : - -# 708| int CallMin(int, int) -# 708| Block 0 -# 708| v708_1(void) = EnterFunction : -# 708| mu708_2(unknown) = AliasedDefinition : -# 708| mu708_3(unknown) = UnmodeledDefinition : -# 708| r708_4(glval) = VariableAddress[x] : -# 708| m708_5(int) = InitializeParameter[x] : &:r708_4 -# 708| r708_6(glval) = VariableAddress[y] : -# 708| m708_7(int) = InitializeParameter[y] : &:r708_6 -# 709| r709_1(glval) = VariableAddress[#return] : -# 709| r709_2(glval) = FunctionAddress[min] : -# 709| r709_3(glval) = VariableAddress[x] : -# 709| r709_4(int) = Load : &:r709_3, m708_5 -# 709| r709_5(glval) = VariableAddress[y] : -# 709| r709_6(int) = Load : &:r709_5, m708_7 -# 709| r709_7(int) = Call : func:r709_2, 0:r709_4, 1:r709_6 -# 709| mu709_8(unknown) = ^CallSideEffect : ~mu708_3 -# 709| m709_9(int) = Store : &:r709_1, r709_7 -# 708| r708_8(glval) = VariableAddress[#return] : -# 708| v708_9(void) = ReturnValue : &:r708_8, m709_9 -# 708| v708_10(void) = UnmodeledUse : mu* -# 708| v708_11(void) = AliasedUse : ~mu708_3 -# 708| v708_12(void) = ExitFunction : - -# 715| long Outer::Func(void*, char) -# 715| Block 0 -# 715| v715_1(void) = EnterFunction : -# 715| mu715_2(unknown) = AliasedDefinition : -# 715| mu715_3(unknown) = UnmodeledDefinition : -# 715| r715_4(glval) = VariableAddress[x] : -# 715| m715_5(void *) = InitializeParameter[x] : &:r715_4 -# 715| r715_6(void *) = Load : &:r715_4, m715_5 -# 715| mu715_7(unknown) = InitializeIndirection[x] : &:r715_6 -# 715| r715_8(glval) = VariableAddress[y] : -# 715| m715_9(char) = InitializeParameter[y] : &:r715_8 -# 716| r716_1(glval) = VariableAddress[#return] : -# 716| r716_2(long) = Constant[0] : -# 716| m716_3(long) = Store : &:r716_1, r716_2 -# 715| v715_10(void) = ReturnIndirection : &:r715_6, ~mu715_3 -# 715| r715_11(glval) = VariableAddress[#return] : -# 715| v715_12(void) = ReturnValue : &:r715_11, m716_3 -# 715| v715_13(void) = UnmodeledUse : mu* -# 715| v715_14(void) = AliasedUse : ~mu715_3 -# 715| v715_15(void) = ExitFunction : - -# 720| double CallNestedTemplateFunc() -# 720| Block 0 -# 720| v720_1(void) = EnterFunction : -# 720| mu720_2(unknown) = AliasedDefinition : -# 720| mu720_3(unknown) = UnmodeledDefinition : -# 721| r721_1(glval) = VariableAddress[#return] : -# 721| r721_2(glval) = FunctionAddress[Func] : -# 721| r721_3(void *) = Constant[0] : -# 721| r721_4(char) = Constant[111] : -# 721| r721_5(long) = Call : func:r721_2, 0:r721_3, 1:r721_4 -# 721| mu721_6(unknown) = ^CallSideEffect : ~mu720_3 -# 721| v721_7(void) = ^BufferReadSideEffect[0] : &:r721_3, ~mu720_3 -# 721| mu721_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r721_3 -# 721| r721_9(double) = Convert : r721_5 -# 721| m721_10(double) = Store : &:r721_1, r721_9 -# 720| r720_4(glval) = VariableAddress[#return] : -# 720| v720_5(void) = ReturnValue : &:r720_4, m721_10 -# 720| v720_6(void) = UnmodeledUse : mu* -# 720| v720_7(void) = AliasedUse : ~mu720_3 -# 720| v720_8(void) = ExitFunction : - -# 724| void TryCatch(bool) -# 724| Block 0 -# 724| v724_1(void) = EnterFunction : -# 724| mu724_2(unknown) = AliasedDefinition : -# 724| mu724_3(unknown) = UnmodeledDefinition : -# 724| r724_4(glval) = VariableAddress[b] : -# 724| m724_5(bool) = InitializeParameter[b] : &:r724_4 -# 726| r726_1(glval) = VariableAddress[x] : -# 726| r726_2(int) = Constant[5] : -# 726| m726_3(int) = Store : &:r726_1, r726_2 -# 727| r727_1(glval) = VariableAddress[b] : -# 727| r727_2(bool) = Load : &:r727_1, m724_5 -# 727| v727_3(void) = ConditionalBranch : r727_2 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 724| Block 1 -# 724| v724_6(void) = UnmodeledUse : mu* -# 724| v724_7(void) = AliasedUse : ~mu724_3 -# 724| v724_8(void) = ExitFunction : - -# 724| Block 2 -# 724| v724_9(void) = Unwind : -#-----| Goto -> Block 1 - -# 728| Block 3 -# 728| r728_1(glval) = VariableAddress[#throw728:7] : -# 728| r728_2(glval) = StringConstant["string literal"] : -# 728| r728_3(char *) = Convert : r728_2 -# 728| m728_4(char *) = Store : &:r728_1, r728_3 -# 728| v728_5(void) = ThrowValue : &:r728_1, m728_4 -#-----| Exception -> Block 9 - -# 730| Block 4 -# 730| r730_1(glval) = VariableAddress[x] : -# 730| r730_2(int) = Load : &:r730_1, m726_3 -# 730| r730_3(int) = Constant[2] : -# 730| r730_4(bool) = CompareLT : r730_2, r730_3 -# 730| v730_5(void) = ConditionalBranch : r730_4 -#-----| False -> Block 8 -#-----| True -> Block 5 - -# 731| Block 5 -# 731| r731_1(glval) = VariableAddress[b] : -# 731| r731_2(bool) = Load : &:r731_1, m724_5 -# 731| v731_3(void) = ConditionalBranch : r731_2 -#-----| False -> Block 7 -#-----| True -> Block 6 - -# 731| Block 6 -# 731| r731_4(int) = Constant[7] : -# 731| r731_5(glval) = VariableAddress[#temp731:11] : -# 731| m731_6(int) = Store : &:r731_5, r731_4 -# 731| r731_7(glval) = VariableAddress[#temp731:11] : -# 731| r731_8(int) = Load : &:r731_7, m731_6 -# 731| r731_9(glval) = VariableAddress[x] : -# 731| m731_10(int) = Store : &:r731_9, r731_8 -#-----| Goto -> Block 8 - -# 731| Block 7 -# 731| r731_11(glval) = VariableAddress[#throw731:19] : -# 731| m731_12(String) = Uninitialized[#throw731:19] : &:r731_11 -# 731| r731_13(glval) = FunctionAddress[String] : -# 731| r731_14(glval) = StringConstant["String object"] : -# 731| r731_15(char *) = Convert : r731_14 -# 731| v731_16(void) = Call : func:r731_13, this:r731_11, 0:r731_15 -# 731| mu731_17(unknown) = ^CallSideEffect : ~mu724_3 -# 731| m731_18(String) = ^IndirectMayWriteSideEffect[-1] : &:r731_11 -# 731| v731_19(void) = ^BufferReadSideEffect[0] : &:r731_15, ~mu724_3 -# 731| mu731_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r731_15 -# 731| v731_21(void) = ThrowValue : &:r731_11, m731_18 -#-----| Exception -> Block 9 - -# 733| Block 8 -# 733| r733_1(int) = Constant[7] : -# 733| r733_2(glval) = VariableAddress[x] : -# 733| m733_3(int) = Store : &:r733_2, r733_1 -#-----| Goto -> Block 14 - -# 735| Block 9 -# 735| v735_1(void) = CatchByType[const char *] : -#-----| Exception -> Block 11 -#-----| Goto -> Block 10 - -# 735| Block 10 -# 735| r735_2(glval) = VariableAddress[s] : -# 735| m735_3(char *) = InitializeParameter[s] : &:r735_2 -# 735| r735_4(char *) = Load : &:r735_2, m735_3 -# 735| mu735_5(unknown) = InitializeIndirection[s] : &:r735_4 -# 736| r736_1(glval) = VariableAddress[#throw736:5] : -# 736| m736_2(String) = Uninitialized[#throw736:5] : &:r736_1 -# 736| r736_3(glval) = FunctionAddress[String] : -# 736| r736_4(glval) = VariableAddress[s] : -# 736| r736_5(char *) = Load : &:r736_4, m735_3 -# 736| v736_6(void) = Call : func:r736_3, this:r736_1, 0:r736_5 -# 736| mu736_7(unknown) = ^CallSideEffect : ~mu724_3 -# 736| m736_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r736_1 -# 736| v736_9(void) = ^BufferReadSideEffect[0] : &:r736_5, ~mu724_3 -# 736| mu736_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r736_5 -# 736| v736_11(void) = ThrowValue : &:r736_1, m736_8 -#-----| Exception -> Block 2 - -# 738| Block 11 -# 738| v738_1(void) = CatchByType[const String &] : -#-----| Exception -> Block 13 -#-----| Goto -> Block 12 - -# 738| Block 12 -# 738| r738_2(glval) = VariableAddress[e] : -# 738| m738_3(String &) = InitializeParameter[e] : &:r738_2 -# 738| r738_4(String &) = Load : &:r738_2, m738_3 -# 738| mu738_5(unknown) = InitializeIndirection[e] : &:r738_4 -# 738| v738_6(void) = NoOp : -#-----| Goto -> Block 14 - -# 740| Block 13 -# 740| v740_1(void) = CatchAny : -# 741| v741_1(void) = ReThrow : -#-----| Exception -> Block 2 - -# 743| Block 14 -# 743| v743_1(void) = NoOp : -# 724| v724_10(void) = ReturnVoid : -#-----| Goto -> Block 1 - -# 745| Base& Base::operator=(Base const&) -# 745| Block 0 -# 745| v745_1(void) = EnterFunction : -# 745| mu745_2(unknown) = AliasedDefinition : -# 745| mu745_3(unknown) = UnmodeledDefinition : -# 745| r745_4(glval) = InitializeThis : -#-----| r0_1(glval) = VariableAddress[p#0] : -#-----| m0_2(Base &) = InitializeParameter[p#0] : &:r0_1 -#-----| r0_3(Base &) = Load : &:r0_1, m0_2 -#-----| mu0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 -#-----| r0_5(Base *) = CopyValue : r745_4 -#-----| r0_6(glval) = FieldAddress[base_s] : r0_5 -#-----| r0_7(String *) = CopyValue : r0_6 -# 745| r745_5(glval) = FunctionAddress[operator=] : -#-----| r0_8(glval) = VariableAddress[p#0] : -#-----| r0_9(Base &) = Load : &:r0_8, m0_2 -#-----| r0_10(glval) = CopyValue : r0_9 -#-----| r0_11(glval) = FieldAddress[base_s] : r0_10 -#-----| r0_12(String &) = CopyValue : r0_11 -# 745| r745_6(String &) = Call : func:r745_5, this:r0_7, 0:r0_12 -# 745| mu745_7(unknown) = ^CallSideEffect : ~mu745_3 -#-----| v0_13(void) = ^BufferReadSideEffect[-1] : &:r0_7, ~mu745_3 -#-----| v0_14(void) = ^BufferReadSideEffect[0] : &:r0_12, ~mu745_3 -#-----| mu0_15(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_7 -#-----| mu0_16(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_12 -#-----| r0_17(glval) = CopyValue : r745_6 -#-----| r0_18(glval) = VariableAddress[#return] : -#-----| r0_19(Base *) = CopyValue : r745_4 -#-----| r0_20(glval) = CopyValue : r0_19 -#-----| r0_21(Base &) = CopyValue : r0_20 -#-----| m0_22(Base &) = Store : &:r0_18, r0_21 -#-----| v0_23(void) = ReturnIndirection : &:r0_3, ~mu745_3 -# 745| r745_8(glval) = VariableAddress[#return] : -# 745| v745_9(void) = ReturnValue : &:r745_8, m0_22 -# 745| v745_10(void) = UnmodeledUse : mu* -# 745| v745_11(void) = AliasedUse : ~mu745_3 -# 745| v745_12(void) = ExitFunction : - -# 745| void Base::Base(Base const&) -# 745| Block 0 -# 745| v745_1(void) = EnterFunction : -# 745| mu745_2(unknown) = AliasedDefinition : -# 745| mu745_3(unknown) = UnmodeledDefinition : -# 745| r745_4(glval) = InitializeThis : -#-----| r0_1(glval) = VariableAddress[p#0] : -#-----| m0_2(Base &) = InitializeParameter[p#0] : &:r0_1 -#-----| r0_3(Base &) = Load : &:r0_1, m0_2 -#-----| mu0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 -# 745| r745_5(glval) = FieldAddress[base_s] : r745_4 -# 745| r745_6(glval) = FunctionAddress[String] : -# 745| v745_7(void) = Call : func:r745_6, this:r745_5 -# 745| mu745_8(unknown) = ^CallSideEffect : ~mu745_3 -# 745| mu745_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r745_5 -# 745| v745_10(void) = NoOp : -#-----| v0_5(void) = ReturnIndirection : &:r0_3, ~mu745_3 -# 745| v745_11(void) = ReturnVoid : -# 745| v745_12(void) = UnmodeledUse : mu* -# 745| v745_13(void) = AliasedUse : ~mu745_3 -# 745| v745_14(void) = ExitFunction : - -# 748| void Base::Base() -# 748| Block 0 -# 748| v748_1(void) = EnterFunction : -# 748| mu748_2(unknown) = AliasedDefinition : -# 748| mu748_3(unknown) = UnmodeledDefinition : -# 748| r748_4(glval) = InitializeThis : -# 748| r748_5(glval) = FieldAddress[base_s] : r748_4 -# 748| r748_6(glval) = FunctionAddress[String] : -# 748| v748_7(void) = Call : func:r748_6, this:r748_5 -# 748| mu748_8(unknown) = ^CallSideEffect : ~mu748_3 -# 748| mu748_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r748_5 -# 749| v749_1(void) = NoOp : -# 748| v748_10(void) = ReturnVoid : -# 748| v748_11(void) = UnmodeledUse : mu* -# 748| v748_12(void) = AliasedUse : ~mu748_3 -# 748| v748_13(void) = ExitFunction : - -# 750| void Base::~Base() -# 750| Block 0 -# 750| v750_1(void) = EnterFunction : -# 750| mu750_2(unknown) = AliasedDefinition : -# 750| mu750_3(unknown) = UnmodeledDefinition : -# 750| r750_4(glval) = InitializeThis : -# 751| v751_1(void) = NoOp : -# 751| r751_2(glval) = FieldAddress[base_s] : r750_4 -# 751| r751_3(glval) = FunctionAddress[~String] : -# 751| v751_4(void) = Call : func:r751_3, this:r751_2 -# 751| mu751_5(unknown) = ^CallSideEffect : ~mu750_3 -# 750| v750_5(void) = ReturnVoid : -# 750| v750_6(void) = UnmodeledUse : mu* -# 750| v750_7(void) = AliasedUse : ~mu750_3 -# 750| v750_8(void) = ExitFunction : - -# 754| Middle& Middle::operator=(Middle const&) -# 754| Block 0 -# 754| v754_1(void) = EnterFunction : -# 754| mu754_2(unknown) = AliasedDefinition : -# 754| mu754_3(unknown) = UnmodeledDefinition : -# 754| r754_4(glval) = InitializeThis : -#-----| r0_1(glval) = VariableAddress[p#0] : -#-----| m0_2(Middle &) = InitializeParameter[p#0] : &:r0_1 -#-----| r0_3(Middle &) = Load : &:r0_1, m0_2 -#-----| mu0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 -#-----| r0_5(Middle *) = CopyValue : r754_4 -#-----| r0_6(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_5 -# 754| r754_5(glval) = FunctionAddress[operator=] : -#-----| r0_7(glval) = VariableAddress[p#0] : -#-----| r0_8(Middle &) = Load : &:r0_7, m0_2 -#-----| r0_9(glval) = CopyValue : r0_8 -#-----| r0_10(Middle *) = CopyValue : r0_9 -#-----| r0_11(Base *) = ConvertToNonVirtualBase[Middle : Base] : r0_10 -#-----| r0_12(glval) = CopyValue : r0_11 -#-----| r0_13(Base &) = CopyValue : r0_12 -# 754| r754_6(Base &) = Call : func:r754_5, this:r0_6, 0:r0_13 -# 754| mu754_7(unknown) = ^CallSideEffect : ~mu754_3 -#-----| v0_14(void) = ^BufferReadSideEffect[-1] : &:r0_6, ~mu754_3 -#-----| v0_15(void) = ^BufferReadSideEffect[0] : &:r0_13, ~mu754_3 -#-----| mu0_16(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_6 -#-----| mu0_17(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_13 -#-----| r0_18(glval) = CopyValue : r754_6 -#-----| r0_19(Middle *) = CopyValue : r754_4 -#-----| r0_20(glval) = FieldAddress[middle_s] : r0_19 -#-----| r0_21(String *) = CopyValue : r0_20 -# 754| r754_8(glval) = FunctionAddress[operator=] : -#-----| r0_22(glval) = VariableAddress[p#0] : -#-----| r0_23(Middle &) = Load : &:r0_22, m0_2 -#-----| r0_24(glval) = CopyValue : r0_23 -#-----| r0_25(glval) = FieldAddress[middle_s] : r0_24 -#-----| r0_26(String &) = CopyValue : r0_25 -# 754| r754_9(String &) = Call : func:r754_8, this:r0_21, 0:r0_26 -# 754| mu754_10(unknown) = ^CallSideEffect : ~mu754_3 -#-----| v0_27(void) = ^BufferReadSideEffect[-1] : &:r0_21, ~mu754_3 -#-----| v0_28(void) = ^BufferReadSideEffect[0] : &:r0_26, ~mu754_3 -#-----| mu0_29(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_21 -#-----| mu0_30(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_26 -#-----| r0_31(glval) = CopyValue : r754_9 -#-----| r0_32(glval) = VariableAddress[#return] : -#-----| r0_33(Middle *) = CopyValue : r754_4 -#-----| r0_34(glval) = CopyValue : r0_33 -#-----| r0_35(Middle &) = CopyValue : r0_34 -#-----| m0_36(Middle &) = Store : &:r0_32, r0_35 -#-----| v0_37(void) = ReturnIndirection : &:r0_3, ~mu754_3 -# 754| r754_11(glval) = VariableAddress[#return] : -# 754| v754_12(void) = ReturnValue : &:r754_11, m0_36 -# 754| v754_13(void) = UnmodeledUse : mu* -# 754| v754_14(void) = AliasedUse : ~mu754_3 -# 754| v754_15(void) = ExitFunction : - -# 757| void Middle::Middle() -# 757| Block 0 -# 757| v757_1(void) = EnterFunction : -# 757| mu757_2(unknown) = AliasedDefinition : -# 757| mu757_3(unknown) = UnmodeledDefinition : -# 757| r757_4(glval) = InitializeThis : -# 757| r757_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r757_4 -# 757| r757_6(glval) = FunctionAddress[Base] : -# 757| v757_7(void) = Call : func:r757_6, this:r757_5 -# 757| mu757_8(unknown) = ^CallSideEffect : ~mu757_3 -# 757| mu757_9(Base) = ^IndirectMayWriteSideEffect[-1] : &:r757_5 -# 757| r757_10(glval) = FieldAddress[middle_s] : r757_4 -# 757| r757_11(glval) = FunctionAddress[String] : -# 757| v757_12(void) = Call : func:r757_11, this:r757_10 -# 757| mu757_13(unknown) = ^CallSideEffect : ~mu757_3 -# 757| mu757_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r757_10 -# 758| v758_1(void) = NoOp : -# 757| v757_15(void) = ReturnVoid : -# 757| v757_16(void) = UnmodeledUse : mu* -# 757| v757_17(void) = AliasedUse : ~mu757_3 -# 757| v757_18(void) = ExitFunction : - -# 759| void Middle::~Middle() -# 759| Block 0 -# 759| v759_1(void) = EnterFunction : -# 759| mu759_2(unknown) = AliasedDefinition : -# 759| mu759_3(unknown) = UnmodeledDefinition : -# 759| r759_4(glval) = InitializeThis : -# 760| v760_1(void) = NoOp : -# 760| r760_2(glval) = FieldAddress[middle_s] : r759_4 -# 760| r760_3(glval) = FunctionAddress[~String] : -# 760| v760_4(void) = Call : func:r760_3, this:r760_2 -# 760| mu760_5(unknown) = ^CallSideEffect : ~mu759_3 -# 760| r760_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r759_4 -# 760| r760_7(glval) = FunctionAddress[~Base] : -# 760| v760_8(void) = Call : func:r760_7, this:r760_6 -# 760| mu760_9(unknown) = ^CallSideEffect : ~mu759_3 -# 759| v759_5(void) = ReturnVoid : -# 759| v759_6(void) = UnmodeledUse : mu* -# 759| v759_7(void) = AliasedUse : ~mu759_3 -# 759| v759_8(void) = ExitFunction : - -# 763| Derived& Derived::operator=(Derived const&) -# 763| Block 0 -# 763| v763_1(void) = EnterFunction : -# 763| mu763_2(unknown) = AliasedDefinition : -# 763| mu763_3(unknown) = UnmodeledDefinition : -# 763| r763_4(glval) = InitializeThis : -#-----| r0_1(glval) = VariableAddress[p#0] : -#-----| m0_2(Derived &) = InitializeParameter[p#0] : &:r0_1 -#-----| r0_3(Derived &) = Load : &:r0_1, m0_2 -#-----| mu0_4(unknown) = InitializeIndirection[p#0] : &:r0_3 -#-----| r0_5(Derived *) = CopyValue : r763_4 -#-----| r0_6(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_5 -# 763| r763_5(glval) = FunctionAddress[operator=] : -#-----| r0_7(glval) = VariableAddress[p#0] : -#-----| r0_8(Derived &) = Load : &:r0_7, m0_2 -#-----| r0_9(glval) = CopyValue : r0_8 -#-----| r0_10(Derived *) = CopyValue : r0_9 -#-----| r0_11(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r0_10 -#-----| r0_12(glval) = CopyValue : r0_11 -#-----| r0_13(Middle &) = CopyValue : r0_12 -# 763| r763_6(Middle &) = Call : func:r763_5, this:r0_6, 0:r0_13 -# 763| mu763_7(unknown) = ^CallSideEffect : ~mu763_3 -#-----| v0_14(void) = ^BufferReadSideEffect[-1] : &:r0_6, ~mu763_3 -#-----| v0_15(void) = ^BufferReadSideEffect[0] : &:r0_13, ~mu763_3 -#-----| mu0_16(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_6 -#-----| mu0_17(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_13 -#-----| r0_18(glval) = CopyValue : r763_6 -#-----| r0_19(Derived *) = CopyValue : r763_4 -#-----| r0_20(glval) = FieldAddress[derived_s] : r0_19 -#-----| r0_21(String *) = CopyValue : r0_20 -# 763| r763_8(glval) = FunctionAddress[operator=] : -#-----| r0_22(glval) = VariableAddress[p#0] : -#-----| r0_23(Derived &) = Load : &:r0_22, m0_2 -#-----| r0_24(glval) = CopyValue : r0_23 -#-----| r0_25(glval) = FieldAddress[derived_s] : r0_24 -#-----| r0_26(String &) = CopyValue : r0_25 -# 763| r763_9(String &) = Call : func:r763_8, this:r0_21, 0:r0_26 -# 763| mu763_10(unknown) = ^CallSideEffect : ~mu763_3 -#-----| v0_27(void) = ^BufferReadSideEffect[-1] : &:r0_21, ~mu763_3 -#-----| v0_28(void) = ^BufferReadSideEffect[0] : &:r0_26, ~mu763_3 -#-----| mu0_29(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_21 -#-----| mu0_30(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_26 -#-----| r0_31(glval) = CopyValue : r763_9 -#-----| r0_32(glval) = VariableAddress[#return] : -#-----| r0_33(Derived *) = CopyValue : r763_4 -#-----| r0_34(glval) = CopyValue : r0_33 -#-----| r0_35(Derived &) = CopyValue : r0_34 -#-----| m0_36(Derived &) = Store : &:r0_32, r0_35 -#-----| v0_37(void) = ReturnIndirection : &:r0_3, ~mu763_3 -# 763| r763_11(glval) = VariableAddress[#return] : -# 763| v763_12(void) = ReturnValue : &:r763_11, m0_36 -# 763| v763_13(void) = UnmodeledUse : mu* -# 763| v763_14(void) = AliasedUse : ~mu763_3 -# 763| v763_15(void) = ExitFunction : - -# 766| void Derived::Derived() -# 766| Block 0 -# 766| v766_1(void) = EnterFunction : -# 766| mu766_2(unknown) = AliasedDefinition : -# 766| mu766_3(unknown) = UnmodeledDefinition : -# 766| r766_4(glval) = InitializeThis : -# 766| r766_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r766_4 -# 766| r766_6(glval) = FunctionAddress[Middle] : -# 766| v766_7(void) = Call : func:r766_6, this:r766_5 -# 766| mu766_8(unknown) = ^CallSideEffect : ~mu766_3 -# 766| mu766_9(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r766_5 -# 766| r766_10(glval) = FieldAddress[derived_s] : r766_4 -# 766| r766_11(glval) = FunctionAddress[String] : -# 766| v766_12(void) = Call : func:r766_11, this:r766_10 -# 766| mu766_13(unknown) = ^CallSideEffect : ~mu766_3 -# 766| mu766_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r766_10 -# 767| v767_1(void) = NoOp : -# 766| v766_15(void) = ReturnVoid : -# 766| v766_16(void) = UnmodeledUse : mu* -# 766| v766_17(void) = AliasedUse : ~mu766_3 -# 766| v766_18(void) = ExitFunction : - -# 768| void Derived::~Derived() -# 768| Block 0 -# 768| v768_1(void) = EnterFunction : -# 768| mu768_2(unknown) = AliasedDefinition : -# 768| mu768_3(unknown) = UnmodeledDefinition : -# 768| r768_4(glval) = InitializeThis : -# 769| v769_1(void) = NoOp : -# 769| r769_2(glval) = FieldAddress[derived_s] : r768_4 -# 769| r769_3(glval) = FunctionAddress[~String] : -# 769| v769_4(void) = Call : func:r769_3, this:r769_2 -# 769| mu769_5(unknown) = ^CallSideEffect : ~mu768_3 -# 769| r769_6(glval) = ConvertToNonVirtualBase[Derived : Middle] : r768_4 -# 769| r769_7(glval) = FunctionAddress[~Middle] : -# 769| v769_8(void) = Call : func:r769_7, this:r769_6 -# 769| mu769_9(unknown) = ^CallSideEffect : ~mu768_3 -# 768| v768_5(void) = ReturnVoid : -# 768| v768_6(void) = UnmodeledUse : mu* -# 768| v768_7(void) = AliasedUse : ~mu768_3 -# 768| v768_8(void) = ExitFunction : - -# 775| void MiddleVB1::MiddleVB1() -# 775| Block 0 -# 775| v775_1(void) = EnterFunction : -# 775| mu775_2(unknown) = AliasedDefinition : -# 775| mu775_3(unknown) = UnmodeledDefinition : -# 775| r775_4(glval) = InitializeThis : -# 775| r775_5(glval) = ConvertToNonVirtualBase[MiddleVB1 : Base] : r775_4 -# 775| r775_6(glval) = FunctionAddress[Base] : -# 775| v775_7(void) = Call : func:r775_6, this:r775_5 -# 775| mu775_8(unknown) = ^CallSideEffect : ~mu775_3 -# 775| mu775_9(Base) = ^IndirectMayWriteSideEffect[-1] : &:r775_5 -# 775| r775_10(glval) = FieldAddress[middlevb1_s] : r775_4 -# 775| r775_11(glval) = FunctionAddress[String] : -# 775| v775_12(void) = Call : func:r775_11, this:r775_10 -# 775| mu775_13(unknown) = ^CallSideEffect : ~mu775_3 -# 775| mu775_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r775_10 -# 776| v776_1(void) = NoOp : -# 775| v775_15(void) = ReturnVoid : -# 775| v775_16(void) = UnmodeledUse : mu* -# 775| v775_17(void) = AliasedUse : ~mu775_3 -# 775| v775_18(void) = ExitFunction : - -# 777| void MiddleVB1::~MiddleVB1() -# 777| Block 0 -# 777| v777_1(void) = EnterFunction : -# 777| mu777_2(unknown) = AliasedDefinition : -# 777| mu777_3(unknown) = UnmodeledDefinition : -# 777| r777_4(glval) = InitializeThis : -# 778| v778_1(void) = NoOp : -# 778| r778_2(glval) = FieldAddress[middlevb1_s] : r777_4 -# 778| r778_3(glval) = FunctionAddress[~String] : -# 778| v778_4(void) = Call : func:r778_3, this:r778_2 -# 778| mu778_5(unknown) = ^CallSideEffect : ~mu777_3 -# 778| r778_6(glval) = ConvertToNonVirtualBase[MiddleVB1 : Base] : r777_4 -# 778| r778_7(glval) = FunctionAddress[~Base] : -# 778| v778_8(void) = Call : func:r778_7, this:r778_6 -# 778| mu778_9(unknown) = ^CallSideEffect : ~mu777_3 -# 777| v777_5(void) = ReturnVoid : -# 777| v777_6(void) = UnmodeledUse : mu* -# 777| v777_7(void) = AliasedUse : ~mu777_3 -# 777| v777_8(void) = ExitFunction : - -# 784| void MiddleVB2::MiddleVB2() -# 784| Block 0 -# 784| v784_1(void) = EnterFunction : -# 784| mu784_2(unknown) = AliasedDefinition : -# 784| mu784_3(unknown) = UnmodeledDefinition : -# 784| r784_4(glval) = InitializeThis : -# 784| r784_5(glval) = ConvertToNonVirtualBase[MiddleVB2 : Base] : r784_4 -# 784| r784_6(glval) = FunctionAddress[Base] : -# 784| v784_7(void) = Call : func:r784_6, this:r784_5 -# 784| mu784_8(unknown) = ^CallSideEffect : ~mu784_3 -# 784| mu784_9(Base) = ^IndirectMayWriteSideEffect[-1] : &:r784_5 -# 784| r784_10(glval) = FieldAddress[middlevb2_s] : r784_4 -# 784| r784_11(glval) = FunctionAddress[String] : -# 784| v784_12(void) = Call : func:r784_11, this:r784_10 -# 784| mu784_13(unknown) = ^CallSideEffect : ~mu784_3 -# 784| mu784_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r784_10 -# 785| v785_1(void) = NoOp : -# 784| v784_15(void) = ReturnVoid : -# 784| v784_16(void) = UnmodeledUse : mu* -# 784| v784_17(void) = AliasedUse : ~mu784_3 -# 784| v784_18(void) = ExitFunction : - -# 786| void MiddleVB2::~MiddleVB2() -# 786| Block 0 -# 786| v786_1(void) = EnterFunction : -# 786| mu786_2(unknown) = AliasedDefinition : -# 786| mu786_3(unknown) = UnmodeledDefinition : -# 786| r786_4(glval) = InitializeThis : -# 787| v787_1(void) = NoOp : -# 787| r787_2(glval) = FieldAddress[middlevb2_s] : r786_4 -# 787| r787_3(glval) = FunctionAddress[~String] : -# 787| v787_4(void) = Call : func:r787_3, this:r787_2 -# 787| mu787_5(unknown) = ^CallSideEffect : ~mu786_3 -# 787| r787_6(glval) = ConvertToNonVirtualBase[MiddleVB2 : Base] : r786_4 -# 787| r787_7(glval) = FunctionAddress[~Base] : -# 787| v787_8(void) = Call : func:r787_7, this:r787_6 -# 787| mu787_9(unknown) = ^CallSideEffect : ~mu786_3 -# 786| v786_5(void) = ReturnVoid : -# 786| v786_6(void) = UnmodeledUse : mu* -# 786| v786_7(void) = AliasedUse : ~mu786_3 -# 786| v786_8(void) = ExitFunction : - -# 793| void DerivedVB::DerivedVB() -# 793| Block 0 -# 793| v793_1(void) = EnterFunction : -# 793| mu793_2(unknown) = AliasedDefinition : -# 793| mu793_3(unknown) = UnmodeledDefinition : -# 793| r793_4(glval) = InitializeThis : -# 793| r793_5(glval) = ConvertToNonVirtualBase[DerivedVB : Base] : r793_4 -# 793| r793_6(glval) = FunctionAddress[Base] : -# 793| v793_7(void) = Call : func:r793_6, this:r793_5 -# 793| mu793_8(unknown) = ^CallSideEffect : ~mu793_3 -# 793| mu793_9(Base) = ^IndirectMayWriteSideEffect[-1] : &:r793_5 -# 793| r793_10(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB1] : r793_4 -# 793| r793_11(glval) = FunctionAddress[MiddleVB1] : -# 793| v793_12(void) = Call : func:r793_11, this:r793_10 -# 793| mu793_13(unknown) = ^CallSideEffect : ~mu793_3 -# 793| mu793_14(MiddleVB1) = ^IndirectMayWriteSideEffect[-1] : &:r793_10 -# 793| r793_15(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB2] : r793_4 -# 793| r793_16(glval) = FunctionAddress[MiddleVB2] : -# 793| v793_17(void) = Call : func:r793_16, this:r793_15 -# 793| mu793_18(unknown) = ^CallSideEffect : ~mu793_3 -# 793| mu793_19(MiddleVB2) = ^IndirectMayWriteSideEffect[-1] : &:r793_15 -# 793| r793_20(glval) = FieldAddress[derivedvb_s] : r793_4 -# 793| r793_21(glval) = FunctionAddress[String] : -# 793| v793_22(void) = Call : func:r793_21, this:r793_20 -# 793| mu793_23(unknown) = ^CallSideEffect : ~mu793_3 -# 793| mu793_24(String) = ^IndirectMayWriteSideEffect[-1] : &:r793_20 -# 794| v794_1(void) = NoOp : -# 793| v793_25(void) = ReturnVoid : -# 793| v793_26(void) = UnmodeledUse : mu* -# 793| v793_27(void) = AliasedUse : ~mu793_3 -# 793| v793_28(void) = ExitFunction : - -# 795| void DerivedVB::~DerivedVB() -# 795| Block 0 -# 795| v795_1(void) = EnterFunction : -# 795| mu795_2(unknown) = AliasedDefinition : -# 795| mu795_3(unknown) = UnmodeledDefinition : -# 795| r795_4(glval) = InitializeThis : -# 796| v796_1(void) = NoOp : -# 796| r796_2(glval) = FieldAddress[derivedvb_s] : r795_4 -# 796| r796_3(glval) = FunctionAddress[~String] : -# 796| v796_4(void) = Call : func:r796_3, this:r796_2 -# 796| mu796_5(unknown) = ^CallSideEffect : ~mu795_3 -# 796| r796_6(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB2] : r795_4 -# 796| r796_7(glval) = FunctionAddress[~MiddleVB2] : -# 796| v796_8(void) = Call : func:r796_7, this:r796_6 -# 796| mu796_9(unknown) = ^CallSideEffect : ~mu795_3 -# 796| r796_10(glval) = ConvertToNonVirtualBase[DerivedVB : MiddleVB1] : r795_4 -# 796| r796_11(glval) = FunctionAddress[~MiddleVB1] : -# 796| v796_12(void) = Call : func:r796_11, this:r796_10 -# 796| mu796_13(unknown) = ^CallSideEffect : ~mu795_3 -# 796| r796_14(glval) = ConvertToNonVirtualBase[DerivedVB : Base] : r795_4 -# 796| r796_15(glval) = FunctionAddress[~Base] : -# 796| v796_16(void) = Call : func:r796_15, this:r796_14 -# 796| mu796_17(unknown) = ^CallSideEffect : ~mu795_3 -# 795| v795_5(void) = ReturnVoid : -# 795| v795_6(void) = UnmodeledUse : mu* -# 795| v795_7(void) = AliasedUse : ~mu795_3 -# 795| v795_8(void) = ExitFunction : - -# 799| void HierarchyConversions() -# 799| Block 0 -# 799| v799_1(void) = EnterFunction : -# 799| mu799_2(unknown) = AliasedDefinition : -# 799| mu799_3(unknown) = UnmodeledDefinition : -# 800| r800_1(glval) = VariableAddress[b] : -# 800| mu800_2(Base) = Uninitialized[b] : &:r800_1 -# 800| r800_3(glval) = FunctionAddress[Base] : -# 800| v800_4(void) = Call : func:r800_3, this:r800_1 -# 800| mu800_5(unknown) = ^CallSideEffect : ~mu799_3 -# 800| mu800_6(Base) = ^IndirectMayWriteSideEffect[-1] : &:r800_1 -# 801| r801_1(glval) = VariableAddress[m] : -# 801| mu801_2(Middle) = Uninitialized[m] : &:r801_1 -# 801| r801_3(glval) = FunctionAddress[Middle] : -# 801| v801_4(void) = Call : func:r801_3, this:r801_1 -# 801| mu801_5(unknown) = ^CallSideEffect : ~mu799_3 -# 801| mu801_6(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r801_1 -# 802| r802_1(glval) = VariableAddress[d] : -# 802| mu802_2(Derived) = Uninitialized[d] : &:r802_1 -# 802| r802_3(glval) = FunctionAddress[Derived] : -# 802| v802_4(void) = Call : func:r802_3, this:r802_1 -# 802| mu802_5(unknown) = ^CallSideEffect : ~mu799_3 -# 802| mu802_6(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r802_1 -# 804| r804_1(glval) = VariableAddress[pb] : -# 804| r804_2(glval) = VariableAddress[b] : -# 804| r804_3(Base *) = CopyValue : r804_2 -# 804| m804_4(Base *) = Store : &:r804_1, r804_3 -# 805| r805_1(glval) = VariableAddress[pm] : -# 805| r805_2(glval) = VariableAddress[m] : -# 805| r805_3(Middle *) = CopyValue : r805_2 -# 805| m805_4(Middle *) = Store : &:r805_1, r805_3 -# 806| r806_1(glval) = VariableAddress[pd] : -# 806| r806_2(glval) = VariableAddress[d] : -# 806| r806_3(Derived *) = CopyValue : r806_2 -# 806| m806_4(Derived *) = Store : &:r806_1, r806_3 -# 808| r808_1(glval) = VariableAddress[b] : -# 808| r808_2(glval) = FunctionAddress[operator=] : -# 808| r808_3(glval) = VariableAddress[m] : -# 808| r808_4(glval) = ConvertToNonVirtualBase[Middle : Base] : r808_3 -# 808| r808_5(Base &) = CopyValue : r808_4 -# 808| r808_6(Base &) = Call : func:r808_2, this:r808_1, 0:r808_5 -# 808| mu808_7(unknown) = ^CallSideEffect : ~mu799_3 -# 808| v808_8(void) = ^BufferReadSideEffect[-1] : &:r808_1, ~mu799_3 -# 808| v808_9(void) = ^BufferReadSideEffect[0] : &:r808_5, ~mu799_3 -# 808| mu808_10(Base) = ^IndirectMayWriteSideEffect[-1] : &:r808_1 -# 808| mu808_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r808_5 -# 808| r808_12(glval) = CopyValue : r808_6 -# 809| r809_1(glval) = VariableAddress[b] : -# 809| r809_2(glval) = FunctionAddress[operator=] : -# 809| r809_3(glval) = FunctionAddress[Base] : -# 809| r809_4(glval) = VariableAddress[m] : -# 809| r809_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r809_4 -# 809| r809_6(Base &) = CopyValue : r809_5 -# 809| v809_7(void) = Call : func:r809_3, 0:r809_6 -# 809| mu809_8(unknown) = ^CallSideEffect : ~mu799_3 -# 809| mu809_9(Base) = ^IndirectMayWriteSideEffect[-1] : -# 809| v809_10(void) = ^BufferReadSideEffect[0] : &:r809_6, ~mu799_3 -# 809| mu809_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r809_6 -# 809| r809_12(glval) = Convert : v809_7 -# 809| r809_13(Base &) = CopyValue : r809_12 -# 809| r809_14(Base &) = Call : func:r809_2, this:r809_1, 0:r809_13 -# 809| mu809_15(unknown) = ^CallSideEffect : ~mu799_3 -# 809| v809_16(void) = ^BufferReadSideEffect[-1] : &:r809_1, ~mu799_3 -# 809| v809_17(void) = ^BufferReadSideEffect[0] : &:r809_13, ~mu799_3 -# 809| mu809_18(Base) = ^IndirectMayWriteSideEffect[-1] : &:r809_1 -# 809| mu809_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r809_13 -# 809| r809_20(glval) = CopyValue : r809_14 -# 810| r810_1(glval) = VariableAddress[b] : -# 810| r810_2(glval) = FunctionAddress[operator=] : -# 810| r810_3(glval) = FunctionAddress[Base] : -# 810| r810_4(glval) = VariableAddress[m] : -# 810| r810_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r810_4 -# 810| r810_6(Base &) = CopyValue : r810_5 -# 810| v810_7(void) = Call : func:r810_3, 0:r810_6 -# 810| mu810_8(unknown) = ^CallSideEffect : ~mu799_3 -# 810| mu810_9(Base) = ^IndirectMayWriteSideEffect[-1] : -# 810| v810_10(void) = ^BufferReadSideEffect[0] : &:r810_6, ~mu799_3 -# 810| mu810_11(unknown) = ^BufferMayWriteSideEffect[0] : &:r810_6 -# 810| r810_12(glval) = Convert : v810_7 -# 810| r810_13(Base &) = CopyValue : r810_12 -# 810| r810_14(Base &) = Call : func:r810_2, this:r810_1, 0:r810_13 -# 810| mu810_15(unknown) = ^CallSideEffect : ~mu799_3 -# 810| v810_16(void) = ^BufferReadSideEffect[-1] : &:r810_1, ~mu799_3 -# 810| v810_17(void) = ^BufferReadSideEffect[0] : &:r810_13, ~mu799_3 -# 810| mu810_18(Base) = ^IndirectMayWriteSideEffect[-1] : &:r810_1 -# 810| mu810_19(unknown) = ^BufferMayWriteSideEffect[0] : &:r810_13 -# 810| r810_20(glval) = CopyValue : r810_14 -# 811| r811_1(glval) = VariableAddress[pm] : -# 811| r811_2(Middle *) = Load : &:r811_1, m805_4 -# 811| r811_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r811_2 -# 811| r811_4(glval) = VariableAddress[pb] : -# 811| m811_5(Base *) = Store : &:r811_4, r811_3 -# 812| r812_1(glval) = VariableAddress[pm] : -# 812| r812_2(Middle *) = Load : &:r812_1, m805_4 -# 812| r812_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r812_2 -# 812| r812_4(glval) = VariableAddress[pb] : -# 812| m812_5(Base *) = Store : &:r812_4, r812_3 -# 813| r813_1(glval) = VariableAddress[pm] : -# 813| r813_2(Middle *) = Load : &:r813_1, m805_4 -# 813| r813_3(Base *) = ConvertToNonVirtualBase[Middle : Base] : r813_2 -# 813| r813_4(glval) = VariableAddress[pb] : -# 813| m813_5(Base *) = Store : &:r813_4, r813_3 -# 814| r814_1(glval) = VariableAddress[pm] : -# 814| r814_2(Middle *) = Load : &:r814_1, m805_4 -# 814| r814_3(Base *) = Convert : r814_2 -# 814| r814_4(glval) = VariableAddress[pb] : -# 814| m814_5(Base *) = Store : &:r814_4, r814_3 -# 816| r816_1(glval) = VariableAddress[m] : -# 816| r816_2(glval) = FunctionAddress[operator=] : -# 816| r816_3(glval) = VariableAddress[b] : -# 816| r816_4(glval) = ConvertToDerived[Middle : Base] : r816_3 -# 816| r816_5(glval) = Convert : r816_4 -# 816| r816_6(Middle &) = CopyValue : r816_5 -# 816| r816_7(Middle &) = Call : func:r816_2, this:r816_1, 0:r816_6 -# 816| mu816_8(unknown) = ^CallSideEffect : ~mu799_3 -# 816| v816_9(void) = ^BufferReadSideEffect[-1] : &:r816_1, ~mu799_3 -# 816| v816_10(void) = ^BufferReadSideEffect[0] : &:r816_6, ~mu799_3 -# 816| mu816_11(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r816_1 -# 816| mu816_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r816_6 -# 816| r816_13(glval) = CopyValue : r816_7 -# 817| r817_1(glval) = VariableAddress[m] : -# 817| r817_2(glval) = FunctionAddress[operator=] : -# 817| r817_3(glval) = VariableAddress[b] : -# 817| r817_4(glval) = ConvertToDerived[Middle : Base] : r817_3 -# 817| r817_5(glval) = Convert : r817_4 -# 817| r817_6(Middle &) = CopyValue : r817_5 -# 817| r817_7(Middle &) = Call : func:r817_2, this:r817_1, 0:r817_6 -# 817| mu817_8(unknown) = ^CallSideEffect : ~mu799_3 -# 817| v817_9(void) = ^BufferReadSideEffect[-1] : &:r817_1, ~mu799_3 -# 817| v817_10(void) = ^BufferReadSideEffect[0] : &:r817_6, ~mu799_3 -# 817| mu817_11(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r817_1 -# 817| mu817_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r817_6 -# 817| r817_13(glval) = CopyValue : r817_7 -# 818| r818_1(glval) = VariableAddress[pb] : -# 818| r818_2(Base *) = Load : &:r818_1, m814_5 -# 818| r818_3(Middle *) = ConvertToDerived[Middle : Base] : r818_2 -# 818| r818_4(glval) = VariableAddress[pm] : -# 818| m818_5(Middle *) = Store : &:r818_4, r818_3 -# 819| r819_1(glval) = VariableAddress[pb] : -# 819| r819_2(Base *) = Load : &:r819_1, m814_5 -# 819| r819_3(Middle *) = ConvertToDerived[Middle : Base] : r819_2 -# 819| r819_4(glval) = VariableAddress[pm] : -# 819| m819_5(Middle *) = Store : &:r819_4, r819_3 -# 820| r820_1(glval) = VariableAddress[pb] : -# 820| r820_2(Base *) = Load : &:r820_1, m814_5 -# 820| r820_3(Middle *) = Convert : r820_2 -# 820| r820_4(glval) = VariableAddress[pm] : -# 820| m820_5(Middle *) = Store : &:r820_4, r820_3 -# 822| r822_1(glval) = VariableAddress[b] : -# 822| r822_2(glval) = FunctionAddress[operator=] : -# 822| r822_3(glval) = VariableAddress[d] : -# 822| r822_4(glval) = ConvertToNonVirtualBase[Derived : Middle] : r822_3 -# 822| r822_5(glval) = ConvertToNonVirtualBase[Middle : Base] : r822_4 -# 822| r822_6(Base &) = CopyValue : r822_5 -# 822| r822_7(Base &) = Call : func:r822_2, this:r822_1, 0:r822_6 -# 822| mu822_8(unknown) = ^CallSideEffect : ~mu799_3 -# 822| v822_9(void) = ^BufferReadSideEffect[-1] : &:r822_1, ~mu799_3 -# 822| v822_10(void) = ^BufferReadSideEffect[0] : &:r822_6, ~mu799_3 -# 822| mu822_11(Base) = ^IndirectMayWriteSideEffect[-1] : &:r822_1 -# 822| mu822_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r822_6 -# 822| r822_13(glval) = CopyValue : r822_7 -# 823| r823_1(glval) = VariableAddress[b] : -# 823| r823_2(glval) = FunctionAddress[operator=] : -# 823| r823_3(glval) = FunctionAddress[Base] : -# 823| r823_4(glval) = VariableAddress[d] : -# 823| r823_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r823_4 -# 823| r823_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r823_5 -# 823| r823_7(Base &) = CopyValue : r823_6 -# 823| v823_8(void) = Call : func:r823_3, 0:r823_7 -# 823| mu823_9(unknown) = ^CallSideEffect : ~mu799_3 -# 823| mu823_10(Base) = ^IndirectMayWriteSideEffect[-1] : -# 823| v823_11(void) = ^BufferReadSideEffect[0] : &:r823_7, ~mu799_3 -# 823| mu823_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r823_7 -# 823| r823_13(glval) = Convert : v823_8 -# 823| r823_14(Base &) = CopyValue : r823_13 -# 823| r823_15(Base &) = Call : func:r823_2, this:r823_1, 0:r823_14 -# 823| mu823_16(unknown) = ^CallSideEffect : ~mu799_3 -# 823| v823_17(void) = ^BufferReadSideEffect[-1] : &:r823_1, ~mu799_3 -# 823| v823_18(void) = ^BufferReadSideEffect[0] : &:r823_14, ~mu799_3 -# 823| mu823_19(Base) = ^IndirectMayWriteSideEffect[-1] : &:r823_1 -# 823| mu823_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r823_14 -# 823| r823_21(glval) = CopyValue : r823_15 -# 824| r824_1(glval) = VariableAddress[b] : -# 824| r824_2(glval) = FunctionAddress[operator=] : -# 824| r824_3(glval) = FunctionAddress[Base] : -# 824| r824_4(glval) = VariableAddress[d] : -# 824| r824_5(glval) = ConvertToNonVirtualBase[Derived : Middle] : r824_4 -# 824| r824_6(glval) = ConvertToNonVirtualBase[Middle : Base] : r824_5 -# 824| r824_7(Base &) = CopyValue : r824_6 -# 824| v824_8(void) = Call : func:r824_3, 0:r824_7 -# 824| mu824_9(unknown) = ^CallSideEffect : ~mu799_3 -# 824| mu824_10(Base) = ^IndirectMayWriteSideEffect[-1] : -# 824| v824_11(void) = ^BufferReadSideEffect[0] : &:r824_7, ~mu799_3 -# 824| mu824_12(unknown) = ^BufferMayWriteSideEffect[0] : &:r824_7 -# 824| r824_13(glval) = Convert : v824_8 -# 824| r824_14(Base &) = CopyValue : r824_13 -# 824| r824_15(Base &) = Call : func:r824_2, this:r824_1, 0:r824_14 -# 824| mu824_16(unknown) = ^CallSideEffect : ~mu799_3 -# 824| v824_17(void) = ^BufferReadSideEffect[-1] : &:r824_1, ~mu799_3 -# 824| v824_18(void) = ^BufferReadSideEffect[0] : &:r824_14, ~mu799_3 -# 824| mu824_19(Base) = ^IndirectMayWriteSideEffect[-1] : &:r824_1 -# 824| mu824_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r824_14 -# 824| r824_21(glval) = CopyValue : r824_15 -# 825| r825_1(glval) = VariableAddress[pd] : -# 825| r825_2(Derived *) = Load : &:r825_1, m806_4 -# 825| r825_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r825_2 -# 825| r825_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r825_3 -# 825| r825_5(glval) = VariableAddress[pb] : -# 825| m825_6(Base *) = Store : &:r825_5, r825_4 -# 826| r826_1(glval) = VariableAddress[pd] : -# 826| r826_2(Derived *) = Load : &:r826_1, m806_4 -# 826| r826_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r826_2 -# 826| r826_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r826_3 -# 826| r826_5(glval) = VariableAddress[pb] : -# 826| m826_6(Base *) = Store : &:r826_5, r826_4 -# 827| r827_1(glval) = VariableAddress[pd] : -# 827| r827_2(Derived *) = Load : &:r827_1, m806_4 -# 827| r827_3(Middle *) = ConvertToNonVirtualBase[Derived : Middle] : r827_2 -# 827| r827_4(Base *) = ConvertToNonVirtualBase[Middle : Base] : r827_3 -# 827| r827_5(glval) = VariableAddress[pb] : -# 827| m827_6(Base *) = Store : &:r827_5, r827_4 -# 828| r828_1(glval) = VariableAddress[pd] : -# 828| r828_2(Derived *) = Load : &:r828_1, m806_4 -# 828| r828_3(Base *) = Convert : r828_2 -# 828| r828_4(glval) = VariableAddress[pb] : -# 828| m828_5(Base *) = Store : &:r828_4, r828_3 -# 830| r830_1(glval) = VariableAddress[d] : -# 830| r830_2(glval) = FunctionAddress[operator=] : -# 830| r830_3(glval) = VariableAddress[b] : -# 830| r830_4(glval) = ConvertToDerived[Middle : Base] : r830_3 -# 830| r830_5(glval) = ConvertToDerived[Derived : Middle] : r830_4 -# 830| r830_6(glval) = Convert : r830_5 -# 830| r830_7(Derived &) = CopyValue : r830_6 -# 830| r830_8(Derived &) = Call : func:r830_2, this:r830_1, 0:r830_7 -# 830| mu830_9(unknown) = ^CallSideEffect : ~mu799_3 -# 830| v830_10(void) = ^BufferReadSideEffect[-1] : &:r830_1, ~mu799_3 -# 830| v830_11(void) = ^BufferReadSideEffect[0] : &:r830_7, ~mu799_3 -# 830| mu830_12(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r830_1 -# 830| mu830_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r830_7 -# 830| r830_14(glval) = CopyValue : r830_8 -# 831| r831_1(glval) = VariableAddress[d] : -# 831| r831_2(glval) = FunctionAddress[operator=] : -# 831| r831_3(glval) = VariableAddress[b] : -# 831| r831_4(glval) = ConvertToDerived[Middle : Base] : r831_3 -# 831| r831_5(glval) = ConvertToDerived[Derived : Middle] : r831_4 -# 831| r831_6(glval) = Convert : r831_5 -# 831| r831_7(Derived &) = CopyValue : r831_6 -# 831| r831_8(Derived &) = Call : func:r831_2, this:r831_1, 0:r831_7 -# 831| mu831_9(unknown) = ^CallSideEffect : ~mu799_3 -# 831| v831_10(void) = ^BufferReadSideEffect[-1] : &:r831_1, ~mu799_3 -# 831| v831_11(void) = ^BufferReadSideEffect[0] : &:r831_7, ~mu799_3 -# 831| mu831_12(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r831_1 -# 831| mu831_13(unknown) = ^BufferMayWriteSideEffect[0] : &:r831_7 -# 831| r831_14(glval) = CopyValue : r831_8 -# 832| r832_1(glval) = VariableAddress[pb] : -# 832| r832_2(Base *) = Load : &:r832_1, m828_5 -# 832| r832_3(Middle *) = ConvertToDerived[Middle : Base] : r832_2 -# 832| r832_4(Derived *) = ConvertToDerived[Derived : Middle] : r832_3 -# 832| r832_5(glval) = VariableAddress[pd] : -# 832| m832_6(Derived *) = Store : &:r832_5, r832_4 -# 833| r833_1(glval) = VariableAddress[pb] : -# 833| r833_2(Base *) = Load : &:r833_1, m828_5 -# 833| r833_3(Middle *) = ConvertToDerived[Middle : Base] : r833_2 -# 833| r833_4(Derived *) = ConvertToDerived[Derived : Middle] : r833_3 -# 833| r833_5(glval) = VariableAddress[pd] : -# 833| m833_6(Derived *) = Store : &:r833_5, r833_4 -# 834| r834_1(glval) = VariableAddress[pb] : -# 834| r834_2(Base *) = Load : &:r834_1, m828_5 -# 834| r834_3(Derived *) = Convert : r834_2 -# 834| r834_4(glval) = VariableAddress[pd] : -# 834| m834_5(Derived *) = Store : &:r834_4, r834_3 -# 836| r836_1(glval) = VariableAddress[pmv] : -# 836| r836_2(MiddleVB1 *) = Constant[0] : -# 836| m836_3(MiddleVB1 *) = Store : &:r836_1, r836_2 -# 837| r837_1(glval) = VariableAddress[pdv] : -# 837| r837_2(DerivedVB *) = Constant[0] : -# 837| m837_3(DerivedVB *) = Store : &:r837_1, r837_2 -# 838| r838_1(glval) = VariableAddress[pmv] : -# 838| r838_2(MiddleVB1 *) = Load : &:r838_1, m836_3 -# 838| r838_3(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r838_2 -# 838| r838_4(glval) = VariableAddress[pb] : -# 838| m838_5(Base *) = Store : &:r838_4, r838_3 -# 839| r839_1(glval) = VariableAddress[pdv] : -# 839| r839_2(DerivedVB *) = Load : &:r839_1, m837_3 -# 839| r839_3(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r839_2 -# 839| r839_4(glval) = VariableAddress[pb] : -# 839| m839_5(Base *) = Store : &:r839_4, r839_3 -# 840| v840_1(void) = NoOp : -# 799| v799_4(void) = ReturnVoid : -# 799| v799_5(void) = UnmodeledUse : mu* -# 799| v799_6(void) = AliasedUse : ~mu799_3 -# 799| v799_7(void) = ExitFunction : - -# 842| void PolymorphicBase::PolymorphicBase() -# 842| Block 0 -# 842| v842_1(void) = EnterFunction : -# 842| mu842_2(unknown) = AliasedDefinition : -# 842| mu842_3(unknown) = UnmodeledDefinition : -# 842| r842_4(glval) = InitializeThis : -# 842| v842_5(void) = NoOp : -# 842| v842_6(void) = ReturnVoid : -# 842| v842_7(void) = UnmodeledUse : mu* -# 842| v842_8(void) = AliasedUse : ~mu842_3 -# 842| v842_9(void) = ExitFunction : - -# 846| void PolymorphicDerived::PolymorphicDerived() -# 846| Block 0 -# 846| v846_1(void) = EnterFunction : -# 846| mu846_2(unknown) = AliasedDefinition : -# 846| mu846_3(unknown) = UnmodeledDefinition : -# 846| r846_4(glval) = InitializeThis : -# 846| r846_5(glval) = ConvertToNonVirtualBase[PolymorphicDerived : PolymorphicBase] : r846_4 -# 846| r846_6(glval) = FunctionAddress[PolymorphicBase] : -# 846| v846_7(void) = Call : func:r846_6, this:r846_5 -# 846| mu846_8(unknown) = ^CallSideEffect : ~mu846_3 -# 846| mu846_9(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r846_5 -# 846| v846_10(void) = NoOp : -# 846| v846_11(void) = ReturnVoid : -# 846| v846_12(void) = UnmodeledUse : mu* -# 846| v846_13(void) = AliasedUse : ~mu846_3 -# 846| v846_14(void) = ExitFunction : - -# 846| void PolymorphicDerived::~PolymorphicDerived() -# 846| Block 0 -# 846| v846_1(void) = EnterFunction : -# 846| mu846_2(unknown) = AliasedDefinition : -# 846| mu846_3(unknown) = UnmodeledDefinition : -# 846| r846_4(glval) = InitializeThis : -#-----| v0_1(void) = NoOp : -# 846| r846_5(glval) = ConvertToNonVirtualBase[PolymorphicDerived : PolymorphicBase] : r846_4 -# 846| r846_6(glval) = FunctionAddress[~PolymorphicBase] : -# 846| v846_7(void) = Call : func:r846_6, this:r846_5 -# 846| mu846_8(unknown) = ^CallSideEffect : ~mu846_3 -# 846| v846_9(void) = ReturnVoid : -# 846| v846_10(void) = UnmodeledUse : mu* -# 846| v846_11(void) = AliasedUse : ~mu846_3 -# 846| v846_12(void) = ExitFunction : - -# 849| void DynamicCast() -# 849| Block 0 -# 849| v849_1(void) = EnterFunction : -# 849| mu849_2(unknown) = AliasedDefinition : -# 849| mu849_3(unknown) = UnmodeledDefinition : -# 850| r850_1(glval) = VariableAddress[b] : -# 850| m850_2(PolymorphicBase) = Uninitialized[b] : &:r850_1 -#-----| r0_1(glval) = FunctionAddress[PolymorphicBase] : -#-----| v0_2(void) = Call : func:r0_1, this:r850_1 -#-----| mu0_3(unknown) = ^CallSideEffect : ~mu849_3 -#-----| m0_4(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r850_1 -# 851| r851_1(glval) = VariableAddress[d] : -# 851| m851_2(PolymorphicDerived) = Uninitialized[d] : &:r851_1 -# 851| r851_3(glval) = FunctionAddress[PolymorphicDerived] : -# 851| v851_4(void) = Call : func:r851_3, this:r851_1 -# 851| mu851_5(unknown) = ^CallSideEffect : ~mu849_3 -# 851| m851_6(PolymorphicDerived) = ^IndirectMayWriteSideEffect[-1] : &:r851_1 -# 853| r853_1(glval) = VariableAddress[pb] : -# 853| r853_2(glval) = VariableAddress[b] : -# 853| r853_3(PolymorphicBase *) = CopyValue : r853_2 -# 853| m853_4(PolymorphicBase *) = Store : &:r853_1, r853_3 -# 854| r854_1(glval) = VariableAddress[pd] : -# 854| r854_2(glval) = VariableAddress[d] : -# 854| r854_3(PolymorphicDerived *) = CopyValue : r854_2 -# 854| m854_4(PolymorphicDerived *) = Store : &:r854_1, r854_3 -# 857| r857_1(glval) = VariableAddress[pd] : -# 857| r857_2(PolymorphicDerived *) = Load : &:r857_1, m854_4 -# 857| r857_3(PolymorphicBase *) = CheckedConvertOrNull : r857_2 -# 857| r857_4(glval) = VariableAddress[pb] : -# 857| m857_5(PolymorphicBase *) = Store : &:r857_4, r857_3 -# 858| r858_1(glval) = VariableAddress[rb] : -# 858| r858_2(glval) = VariableAddress[d] : -# 858| r858_3(glval) = CheckedConvertOrThrow : r858_2 -# 858| r858_4(PolymorphicBase &) = CopyValue : r858_3 -# 858| m858_5(PolymorphicBase &) = Store : &:r858_1, r858_4 -# 860| r860_1(glval) = VariableAddress[pb] : -# 860| r860_2(PolymorphicBase *) = Load : &:r860_1, m857_5 -# 860| r860_3(PolymorphicDerived *) = CheckedConvertOrNull : r860_2 -# 860| r860_4(glval) = VariableAddress[pd] : -# 860| m860_5(PolymorphicDerived *) = Store : &:r860_4, r860_3 -# 861| r861_1(glval) = VariableAddress[rd] : -# 861| r861_2(glval) = VariableAddress[b] : -# 861| r861_3(glval) = CheckedConvertOrThrow : r861_2 -# 861| r861_4(PolymorphicDerived &) = CopyValue : r861_3 -# 861| m861_5(PolymorphicDerived &) = Store : &:r861_1, r861_4 -# 863| r863_1(glval) = VariableAddress[pv] : -# 863| r863_2(glval) = VariableAddress[pb] : -# 863| r863_3(PolymorphicBase *) = Load : &:r863_2, m857_5 -# 863| r863_4(void *) = DynamicCastToVoid : r863_3 -# 863| m863_5(void *) = Store : &:r863_1, r863_4 -# 864| r864_1(glval) = VariableAddress[pcv] : -# 864| r864_2(glval) = VariableAddress[pd] : -# 864| r864_3(PolymorphicDerived *) = Load : &:r864_2, m860_5 -# 864| r864_4(void *) = DynamicCastToVoid : r864_3 -# 864| m864_5(void *) = Store : &:r864_1, r864_4 -# 865| v865_1(void) = NoOp : -# 849| v849_4(void) = ReturnVoid : -# 849| v849_5(void) = UnmodeledUse : mu* -# 849| v849_6(void) = AliasedUse : ~mu849_3 -# 849| v849_7(void) = ExitFunction : - -# 867| void String::String() -# 867| Block 0 -# 867| v867_1(void) = EnterFunction : -# 867| mu867_2(unknown) = AliasedDefinition : -# 867| mu867_3(unknown) = UnmodeledDefinition : -# 867| r867_4(glval) = InitializeThis : -# 868| r868_1(glval) = FunctionAddress[String] : -# 868| r868_2(glval) = StringConstant[""] : -# 868| r868_3(char *) = Convert : r868_2 -# 868| v868_4(void) = Call : func:r868_1, this:r867_4, 0:r868_3 -# 868| mu868_5(unknown) = ^CallSideEffect : ~mu867_3 -# 868| mu868_6(String) = ^IndirectMayWriteSideEffect[-1] : &:r867_4 -# 868| v868_7(void) = ^BufferReadSideEffect[0] : &:r868_3, ~mu867_3 -# 868| mu868_8(unknown) = ^BufferMayWriteSideEffect[0] : &:r868_3 -# 869| v869_1(void) = NoOp : -# 867| v867_5(void) = ReturnVoid : -# 867| v867_6(void) = UnmodeledUse : mu* -# 867| v867_7(void) = AliasedUse : ~mu867_3 -# 867| v867_8(void) = ExitFunction : - -# 871| void ArrayConversions() -# 871| Block 0 -# 871| v871_1(void) = EnterFunction : -# 871| mu871_2(unknown) = AliasedDefinition : -# 871| mu871_3(unknown) = UnmodeledDefinition : -# 872| r872_1(glval) = VariableAddress[a] : -# 872| m872_2(char[5]) = Uninitialized[a] : &:r872_1 -# 873| r873_1(glval) = VariableAddress[p] : -# 873| r873_2(glval) = VariableAddress[a] : -# 873| r873_3(char *) = Convert : r873_2 -# 873| r873_4(char *) = Convert : r873_3 -# 873| m873_5(char *) = Store : &:r873_1, r873_4 -# 874| r874_1(glval) = StringConstant["test"] : -# 874| r874_2(char *) = Convert : r874_1 -# 874| r874_3(glval) = VariableAddress[p] : -# 874| m874_4(char *) = Store : &:r874_3, r874_2 -# 875| r875_1(glval) = VariableAddress[a] : -# 875| r875_2(char *) = Convert : r875_1 -# 875| r875_3(int) = Constant[0] : -# 875| r875_4(glval) = PointerAdd[1] : r875_2, r875_3 -# 875| r875_5(char *) = CopyValue : r875_4 -# 875| r875_6(char *) = Convert : r875_5 -# 875| r875_7(glval) = VariableAddress[p] : -# 875| m875_8(char *) = Store : &:r875_7, r875_6 -# 876| r876_1(glval) = StringConstant["test"] : -# 876| r876_2(char *) = Convert : r876_1 -# 876| r876_3(int) = Constant[0] : -# 876| r876_4(glval) = PointerAdd[1] : r876_2, r876_3 -# 876| r876_5(char *) = CopyValue : r876_4 -# 876| r876_6(glval) = VariableAddress[p] : -# 876| m876_7(char *) = Store : &:r876_6, r876_5 -# 877| r877_1(glval) = VariableAddress[ra] : -# 877| r877_2(glval) = VariableAddress[a] : -# 877| r877_3(char(&)[5]) = CopyValue : r877_2 -# 877| m877_4(char(&)[5]) = Store : &:r877_1, r877_3 -# 878| r878_1(glval) = VariableAddress[rs] : -# 878| r878_2(glval) = StringConstant["test"] : -# 878| r878_3(char(&)[5]) = CopyValue : r878_2 -# 878| m878_4(char(&)[5]) = Store : &:r878_1, r878_3 -# 879| r879_1(glval) = VariableAddress[pa] : -# 879| r879_2(glval) = VariableAddress[a] : -# 879| r879_3(char(*)[5]) = CopyValue : r879_2 -# 879| r879_4(char(*)[5]) = Convert : r879_3 -# 879| m879_5(char(*)[5]) = Store : &:r879_1, r879_4 -# 880| r880_1(glval) = StringConstant["test"] : -# 880| r880_2(char(*)[5]) = CopyValue : r880_1 -# 880| r880_3(glval) = VariableAddress[pa] : -# 880| m880_4(char(*)[5]) = Store : &:r880_3, r880_2 -# 881| v881_1(void) = NoOp : -# 871| v871_4(void) = ReturnVoid : -# 871| v871_5(void) = UnmodeledUse : mu* -# 871| v871_6(void) = AliasedUse : ~mu871_3 -# 871| v871_7(void) = ExitFunction : - -# 883| void FuncPtrConversions(int(*)(int), void*) -# 883| Block 0 -# 883| v883_1(void) = EnterFunction : -# 883| mu883_2(unknown) = AliasedDefinition : -# 883| mu883_3(unknown) = UnmodeledDefinition : -# 883| r883_4(glval<..(*)(..)>) = VariableAddress[pfn] : -# 883| m883_5(..(*)(..)) = InitializeParameter[pfn] : &:r883_4 -# 883| r883_6(glval) = VariableAddress[p] : -# 883| m883_7(void *) = InitializeParameter[p] : &:r883_6 -# 883| r883_8(void *) = Load : &:r883_6, m883_7 -# 883| mu883_9(unknown) = InitializeIndirection[p] : &:r883_8 -# 884| r884_1(glval<..(*)(..)>) = VariableAddress[pfn] : -# 884| r884_2(..(*)(..)) = Load : &:r884_1, m883_5 -# 884| r884_3(void *) = Convert : r884_2 -# 884| r884_4(glval) = VariableAddress[p] : -# 884| m884_5(void *) = Store : &:r884_4, r884_3 -# 885| r885_1(glval) = VariableAddress[p] : -# 885| r885_2(void *) = Load : &:r885_1, m884_5 -# 885| r885_3(..(*)(..)) = Convert : r885_2 -# 885| r885_4(glval<..(*)(..)>) = VariableAddress[pfn] : -# 885| m885_5(..(*)(..)) = Store : &:r885_4, r885_3 -# 886| v886_1(void) = NoOp : -# 883| v883_10(void) = ReturnIndirection : &:r883_8, ~mu883_3 -# 883| v883_11(void) = ReturnVoid : -# 883| v883_12(void) = UnmodeledUse : mu* -# 883| v883_13(void) = AliasedUse : ~mu883_3 -# 883| v883_14(void) = ExitFunction : - -# 888| void VarArgUsage(int) -# 888| Block 0 -# 888| v888_1(void) = EnterFunction : -# 888| mu888_2(unknown) = AliasedDefinition : -# 888| mu888_3(unknown) = UnmodeledDefinition : -# 888| r888_4(glval) = VariableAddress[x] : -# 888| m888_5(int) = InitializeParameter[x] : &:r888_4 -# 889| r889_1(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 889| m889_2(__va_list_tag[1]) = Uninitialized[args] : &:r889_1 -# 891| r891_1(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 891| r891_2(__va_list_tag *) = Convert : r891_1 -# 891| r891_3(glval) = VariableAddress[x] : -# 891| v891_4(void) = VarArgsStart : 0:r891_2, 1:r891_3 -# 892| r892_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 892| m892_2(__va_list_tag[1]) = Uninitialized[args2] : &:r892_1 -# 893| r893_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 893| r893_2(__va_list_tag *) = Convert : r893_1 -# 893| r893_3(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 893| r893_4(__va_list_tag *) = Convert : r893_3 -# 893| v893_5(void) = VarArgsStart : 0:r893_2, 1:r893_4 -# 894| r894_1(glval) = VariableAddress[d] : -# 894| r894_2(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 894| r894_3(__va_list_tag *) = Convert : r894_2 -# 894| r894_4(glval) = VarArg : 0:r894_3 -# 894| r894_5(double) = Load : &:r894_4, ~mu888_3 -# 894| m894_6(double) = Store : &:r894_1, r894_5 -# 895| r895_1(glval) = VariableAddress[f] : -# 895| r895_2(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 895| r895_3(__va_list_tag *) = Convert : r895_2 -# 895| r895_4(glval) = VarArg : 0:r895_3 -# 895| r895_5(double) = Load : &:r895_4, ~mu888_3 -# 895| r895_6(float) = Convert : r895_5 -# 895| m895_7(float) = Store : &:r895_1, r895_6 -# 896| r896_1(glval<__va_list_tag[1]>) = VariableAddress[args] : -# 896| r896_2(__va_list_tag *) = Convert : r896_1 -# 896| v896_3(void) = VarArgsEnd : 0:r896_2 -# 897| r897_1(glval<__va_list_tag[1]>) = VariableAddress[args2] : -# 897| r897_2(__va_list_tag *) = Convert : r897_1 -# 897| v897_3(void) = VarArgsEnd : 0:r897_2 -# 898| v898_1(void) = NoOp : -# 888| v888_6(void) = ReturnVoid : -# 888| v888_7(void) = UnmodeledUse : mu* -# 888| v888_8(void) = AliasedUse : ~mu888_3 -# 888| v888_9(void) = ExitFunction : - -# 900| void CastToVoid(int) -# 900| Block 0 -# 900| v900_1(void) = EnterFunction : -# 900| mu900_2(unknown) = AliasedDefinition : -# 900| mu900_3(unknown) = UnmodeledDefinition : -# 900| r900_4(glval) = VariableAddress[x] : -# 900| m900_5(int) = InitializeParameter[x] : &:r900_4 -# 901| r901_1(glval) = VariableAddress[x] : -# 901| v901_2(void) = Convert : r901_1 -# 902| v902_1(void) = NoOp : -# 900| v900_6(void) = ReturnVoid : -# 900| v900_7(void) = UnmodeledUse : mu* -# 900| v900_8(void) = AliasedUse : ~mu900_3 -# 900| v900_9(void) = ExitFunction : - -# 904| void ConstantConditions(int) -# 904| Block 0 -# 904| v904_1(void) = EnterFunction : -# 904| mu904_2(unknown) = AliasedDefinition : -# 904| mu904_3(unknown) = UnmodeledDefinition : -# 904| r904_4(glval) = VariableAddress[x] : -# 904| m904_5(int) = InitializeParameter[x] : &:r904_4 -# 905| r905_1(glval) = VariableAddress[a] : -# 905| r905_2(bool) = Constant[1] : -# 905| m905_3(bool) = Store : &:r905_1, r905_2 -# 906| r906_1(glval) = VariableAddress[b] : -# 906| r906_2(bool) = Constant[1] : -# 906| v906_3(void) = ConditionalBranch : r906_2 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 906| Block 1 -# 906| r906_4(glval) = VariableAddress[x] : -# 906| r906_5(int) = Load : &:r906_4, m904_5 -# 906| r906_6(glval) = VariableAddress[#temp906:11] : -# 906| m906_7(int) = Store : &:r906_6, r906_5 -# 906| r906_8(glval) = VariableAddress[#temp906:11] : -# 906| r906_9(int) = Load : &:r906_8, m906_7 -# 906| m906_10(int) = Store : &:r906_1, r906_9 -# 907| v907_1(void) = NoOp : -# 904| v904_6(void) = ReturnVoid : -# 904| v904_7(void) = UnmodeledUse : mu* -# 904| v904_8(void) = AliasedUse : ~mu904_3 -# 904| v904_9(void) = ExitFunction : - -# 904| Block 2 -# 904| v904_10(void) = Unreached : - -# 940| void OperatorNew() -# 940| Block 0 -# 940| v940_1(void) = EnterFunction : -# 940| mu940_2(unknown) = AliasedDefinition : -# 940| mu940_3(unknown) = UnmodeledDefinition : -# 941| r941_1(glval) = FunctionAddress[operator new] : -# 941| r941_2(unsigned long) = Constant[4] : -# 941| r941_3(void *) = Call : func:r941_1, 0:r941_2 -# 941| mu941_4(unknown) = ^CallSideEffect : ~mu940_3 -# 941| r941_5(int *) = Convert : r941_3 -# 942| r942_1(glval) = FunctionAddress[operator new] : -# 942| r942_2(unsigned long) = Constant[4] : -# 942| r942_3(float) = Constant[1.0] : -# 942| r942_4(void *) = Call : func:r942_1, 0:r942_2, 1:r942_3 -# 942| mu942_5(unknown) = ^CallSideEffect : ~mu940_3 -# 942| r942_6(int *) = Convert : r942_4 -# 943| r943_1(glval) = FunctionAddress[operator new] : -# 943| r943_2(unsigned long) = Constant[4] : -# 943| r943_3(void *) = Call : func:r943_1, 0:r943_2 -# 943| mu943_4(unknown) = ^CallSideEffect : ~mu940_3 -# 943| r943_5(int *) = Convert : r943_3 -# 943| r943_6(int) = Constant[0] : -# 943| mu943_7(int) = Store : &:r943_5, r943_6 -# 944| r944_1(glval) = FunctionAddress[operator new] : -# 944| r944_2(unsigned long) = Constant[8] : -# 944| r944_3(void *) = Call : func:r944_1, 0:r944_2 -# 944| mu944_4(unknown) = ^CallSideEffect : ~mu940_3 -# 944| r944_5(String *) = Convert : r944_3 -# 944| r944_6(glval) = FunctionAddress[String] : -# 944| v944_7(void) = Call : func:r944_6, this:r944_5 -# 944| mu944_8(unknown) = ^CallSideEffect : ~mu940_3 -# 944| mu944_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r944_5 -# 945| r945_1(glval) = FunctionAddress[operator new] : -# 945| r945_2(unsigned long) = Constant[8] : -# 945| r945_3(float) = Constant[1.0] : -# 945| r945_4(void *) = Call : func:r945_1, 0:r945_2, 1:r945_3 -# 945| mu945_5(unknown) = ^CallSideEffect : ~mu940_3 -# 945| r945_6(String *) = Convert : r945_4 -# 945| r945_7(glval) = FunctionAddress[String] : -# 945| r945_8(glval) = StringConstant["hello"] : -# 945| r945_9(char *) = Convert : r945_8 -# 945| v945_10(void) = Call : func:r945_7, this:r945_6, 0:r945_9 -# 945| mu945_11(unknown) = ^CallSideEffect : ~mu940_3 -# 945| mu945_12(String) = ^IndirectMayWriteSideEffect[-1] : &:r945_6 -# 945| v945_13(void) = ^BufferReadSideEffect[0] : &:r945_9, ~mu940_3 -# 945| mu945_14(unknown) = ^BufferMayWriteSideEffect[0] : &:r945_9 -# 946| r946_1(glval) = FunctionAddress[operator new] : -# 946| r946_2(unsigned long) = Constant[256] : -# 946| r946_3(align_val_t) = Constant[128] : -# 946| r946_4(void *) = Call : func:r946_1, 0:r946_2, 1:r946_3 -# 946| mu946_5(unknown) = ^CallSideEffect : ~mu940_3 -# 946| r946_6(Overaligned *) = Convert : r946_4 -# 947| r947_1(glval) = FunctionAddress[operator new] : -# 947| r947_2(unsigned long) = Constant[256] : -# 947| r947_3(align_val_t) = Constant[128] : -# 947| r947_4(float) = Constant[1.0] : -# 947| r947_5(void *) = Call : func:r947_1, 0:r947_2, 1:r947_3, 2:r947_4 -# 947| mu947_6(unknown) = ^CallSideEffect : ~mu940_3 -# 947| r947_7(Overaligned *) = Convert : r947_5 -# 947| r947_8(Overaligned) = Constant[0] : -# 947| mu947_9(Overaligned) = Store : &:r947_7, r947_8 -# 948| v948_1(void) = NoOp : -# 940| v940_4(void) = ReturnVoid : -# 940| v940_5(void) = UnmodeledUse : mu* -# 940| v940_6(void) = AliasedUse : ~mu940_3 -# 940| v940_7(void) = ExitFunction : - -# 950| void OperatorNewArray(int) -# 950| Block 0 -# 950| v950_1(void) = EnterFunction : -# 950| mu950_2(unknown) = AliasedDefinition : -# 950| mu950_3(unknown) = UnmodeledDefinition : -# 950| r950_4(glval) = VariableAddress[n] : -# 950| m950_5(int) = InitializeParameter[n] : &:r950_4 -# 951| r951_1(glval) = FunctionAddress[operator new[]] : -# 951| r951_2(unsigned long) = Constant[40] : -# 951| r951_3(void *) = Call : func:r951_1, 0:r951_2 -# 951| mu951_4(unknown) = ^CallSideEffect : ~mu950_3 -# 951| r951_5(int *) = Convert : r951_3 -# 952| r952_1(glval) = FunctionAddress[operator new[]] : -# 952| r952_2(glval) = VariableAddress[n] : -# 952| r952_3(int) = Load : &:r952_2, m950_5 -# 952| r952_4(unsigned long) = Convert : r952_3 -# 952| r952_5(unsigned long) = Constant[4] : -# 952| r952_6(unsigned long) = Mul : r952_4, r952_5 -# 952| r952_7(void *) = Call : func:r952_1, 0:r952_6 -# 952| mu952_8(unknown) = ^CallSideEffect : ~mu950_3 -# 952| r952_9(int *) = Convert : r952_7 -# 953| r953_1(glval) = FunctionAddress[operator new[]] : -# 953| r953_2(glval) = VariableAddress[n] : -# 953| r953_3(int) = Load : &:r953_2, m950_5 -# 953| r953_4(unsigned long) = Convert : r953_3 -# 953| r953_5(unsigned long) = Constant[4] : -# 953| r953_6(unsigned long) = Mul : r953_4, r953_5 -# 953| r953_7(float) = Constant[1.0] : -# 953| r953_8(void *) = Call : func:r953_1, 0:r953_6, 1:r953_7 -# 953| mu953_9(unknown) = ^CallSideEffect : ~mu950_3 -# 953| r953_10(int *) = Convert : r953_8 -# 954| r954_1(glval) = FunctionAddress[operator new[]] : -# 954| r954_2(glval) = VariableAddress[n] : -# 954| r954_3(int) = Load : &:r954_2, m950_5 -# 954| r954_4(unsigned long) = Convert : r954_3 -# 954| r954_5(unsigned long) = Constant[8] : -# 954| r954_6(unsigned long) = Mul : r954_4, r954_5 -# 954| r954_7(void *) = Call : func:r954_1, 0:r954_6 -# 954| mu954_8(unknown) = ^CallSideEffect : ~mu950_3 -# 954| r954_9(String *) = Convert : r954_7 -# 955| r955_1(glval) = FunctionAddress[operator new[]] : -# 955| r955_2(glval) = VariableAddress[n] : -# 955| r955_3(int) = Load : &:r955_2, m950_5 -# 955| r955_4(unsigned long) = Convert : r955_3 -# 955| r955_5(unsigned long) = Constant[256] : -# 955| r955_6(unsigned long) = Mul : r955_4, r955_5 -# 955| r955_7(align_val_t) = Constant[128] : -# 955| r955_8(void *) = Call : func:r955_1, 0:r955_6, 1:r955_7 -# 955| mu955_9(unknown) = ^CallSideEffect : ~mu950_3 -# 955| r955_10(Overaligned *) = Convert : r955_8 -# 956| r956_1(glval) = FunctionAddress[operator new[]] : -# 956| r956_2(unsigned long) = Constant[2560] : -# 956| r956_3(align_val_t) = Constant[128] : -# 956| r956_4(float) = Constant[1.0] : -# 956| r956_5(void *) = Call : func:r956_1, 0:r956_2, 1:r956_3, 2:r956_4 -# 956| mu956_6(unknown) = ^CallSideEffect : ~mu950_3 -# 956| r956_7(Overaligned *) = Convert : r956_5 -# 957| r957_1(glval) = FunctionAddress[operator new[]] : -# 957| r957_2(glval) = VariableAddress[n] : -# 957| r957_3(int) = Load : &:r957_2, m950_5 -# 957| r957_4(unsigned long) = Convert : r957_3 -# 957| r957_5(unsigned long) = Constant[1] : -# 957| r957_6(unsigned long) = Mul : r957_4, r957_5 -# 957| r957_7(void *) = Call : func:r957_1, 0:r957_6 -# 957| mu957_8(unknown) = ^CallSideEffect : ~mu950_3 -# 957| r957_9(DefaultCtorWithDefaultParam *) = Convert : r957_7 -# 958| r958_1(glval) = FunctionAddress[operator new[]] : -# 958| r958_2(glval) = VariableAddress[n] : -# 958| r958_3(int) = Load : &:r958_2, m950_5 -# 958| r958_4(unsigned long) = Convert : r958_3 -# 958| r958_5(unsigned long) = Constant[4] : -# 958| r958_6(unsigned long) = Mul : r958_4, r958_5 -# 958| r958_7(void *) = Call : func:r958_1, 0:r958_6 -# 958| mu958_8(unknown) = ^CallSideEffect : ~mu950_3 -# 958| r958_9(int *) = Convert : r958_7 -# 959| v959_1(void) = NoOp : -# 950| v950_6(void) = ReturnVoid : -# 950| v950_7(void) = UnmodeledUse : mu* -# 950| v950_8(void) = AliasedUse : ~mu950_3 -# 950| v950_9(void) = ExitFunction : - -# 961| int designatedInit() -# 961| Block 0 -# 961| v961_1(void) = EnterFunction : -# 961| mu961_2(unknown) = AliasedDefinition : -# 961| mu961_3(unknown) = UnmodeledDefinition : -# 962| r962_1(glval) = VariableAddress[a1] : -# 962| mu962_2(int[1000]) = Uninitialized[a1] : &:r962_1 -# 962| r962_3(int) = Constant[0] : -# 962| r962_4(glval) = PointerAdd[4] : r962_1, r962_3 -# 962| r962_5(unknown[8]) = Constant[0] : -# 962| mu962_6(unknown[8]) = Store : &:r962_4, r962_5 -# 962| r962_7(int) = Constant[2] : -# 962| r962_8(glval) = PointerAdd[4] : r962_1, r962_7 -# 962| r962_9(int) = Constant[10002] : -# 962| mu962_10(int) = Store : &:r962_8, r962_9 -# 962| r962_11(int) = Constant[3] : -# 962| r962_12(glval) = PointerAdd[4] : r962_1, r962_11 -# 962| r962_13(unknown[3588]) = Constant[0] : -# 962| mu962_14(unknown[3588]) = Store : &:r962_12, r962_13 -# 962| r962_15(int) = Constant[900] : -# 962| r962_16(glval) = PointerAdd[4] : r962_1, r962_15 -# 962| r962_17(int) = Constant[10900] : -# 962| mu962_18(int) = Store : &:r962_16, r962_17 -# 962| r962_19(int) = Constant[901] : -# 962| r962_20(glval) = PointerAdd[4] : r962_1, r962_19 -# 962| r962_21(unknown[396]) = Constant[0] : -# 962| mu962_22(unknown[396]) = Store : &:r962_20, r962_21 -# 963| r963_1(glval) = VariableAddress[#return] : -# 963| r963_2(glval) = VariableAddress[a1] : -# 963| r963_3(int *) = Convert : r963_2 -# 963| r963_4(int) = Constant[900] : -# 963| r963_5(glval) = PointerAdd[4] : r963_3, r963_4 -# 963| r963_6(int) = Load : &:r963_5, ~mu961_3 -# 963| m963_7(int) = Store : &:r963_1, r963_6 -# 961| r961_4(glval) = VariableAddress[#return] : -# 961| v961_5(void) = ReturnValue : &:r961_4, m963_7 -# 961| v961_6(void) = UnmodeledUse : mu* -# 961| v961_7(void) = AliasedUse : ~mu961_3 -# 961| v961_8(void) = ExitFunction : - -# 966| void IfStmtWithDeclaration(int, int) -# 966| Block 0 -# 966| v966_1(void) = EnterFunction : -# 966| mu966_2(unknown) = AliasedDefinition : -# 966| mu966_3(unknown) = UnmodeledDefinition : -# 966| r966_4(glval) = VariableAddress[x] : -# 966| m966_5(int) = InitializeParameter[x] : &:r966_4 -# 966| r966_6(glval) = VariableAddress[y] : -# 966| m966_7(int) = InitializeParameter[y] : &:r966_6 -# 967| r967_1(glval) = VariableAddress[b] : -# 967| r967_2(glval) = VariableAddress[x] : -# 967| r967_3(int) = Load : &:r967_2, m966_5 -# 967| r967_4(glval) = VariableAddress[y] : -# 967| r967_5(int) = Load : &:r967_4, m966_7 -# 967| r967_6(bool) = CompareLT : r967_3, r967_5 -# 967| m967_7(bool) = Store : &:r967_1, r967_6 -# 967| r967_8(glval) = VariableAddress[b] : -# 967| r967_9(bool) = Load : &:r967_8, m967_7 -# 967| r967_10(bool) = CopyValue : r967_9 -# 967| v967_11(void) = ConditionalBranch : r967_10 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 968| Block 1 -# 968| r968_1(int) = Constant[5] : -# 968| r968_2(glval) = VariableAddress[x] : -# 968| m968_3(int) = Store : &:r968_2, r968_1 -#-----| Goto -> Block 6 - -# 970| Block 2 -# 970| r970_1(glval) = VariableAddress[z] : -# 970| r970_2(glval) = VariableAddress[x] : -# 970| r970_3(int) = Load : &:r970_2, m966_5 -# 970| r970_4(glval) = VariableAddress[y] : -# 970| r970_5(int) = Load : &:r970_4, m966_7 -# 970| r970_6(int) = Add : r970_3, r970_5 -# 970| m970_7(int) = Store : &:r970_1, r970_6 -# 970| r970_8(glval) = VariableAddress[z] : -# 970| r970_9(int) = Load : &:r970_8, m970_7 -# 970| r970_10(int) = Constant[0] : -# 970| r970_11(bool) = CompareNE : r970_9, r970_10 -# 970| r970_12(bool) = CopyValue : r970_11 -# 970| v970_13(void) = ConditionalBranch : r970_12 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 971| Block 3 -# 971| r971_1(int) = Constant[7] : -# 971| r971_2(glval) = VariableAddress[y] : -# 971| m971_3(int) = Store : &:r971_2, r971_1 -#-----| Goto -> Block 6 - -# 973| Block 4 -# 973| r973_1(glval) = VariableAddress[p] : -# 973| r973_2(glval) = VariableAddress[x] : -# 973| r973_3(int *) = CopyValue : r973_2 -# 973| m973_4(int *) = Store : &:r973_1, r973_3 -# 973| r973_5(glval) = VariableAddress[p] : -# 973| r973_6(int *) = Load : &:r973_5, m973_4 -# 973| r973_7(int *) = Constant[0] : -# 973| r973_8(bool) = CompareNE : r973_6, r973_7 -# 973| r973_9(bool) = CopyValue : r973_8 -# 973| v973_10(void) = ConditionalBranch : r973_9 -#-----| False -> Block 6 -#-----| True -> Block 5 - -# 974| Block 5 -# 974| r974_1(int) = Constant[2] : -# 974| r974_2(glval) = VariableAddress[p] : -# 974| r974_3(int *) = Load : &:r974_2, m973_4 -# 974| r974_4(glval) = CopyValue : r974_3 -# 974| mu974_5(int) = Store : &:r974_4, r974_1 -#-----| Goto -> Block 6 - -# 976| Block 6 -# 976| v976_1(void) = NoOp : -# 966| v966_8(void) = ReturnVoid : -# 966| v966_9(void) = UnmodeledUse : mu* -# 966| v966_10(void) = AliasedUse : ~mu966_3 -# 966| v966_11(void) = ExitFunction : - -# 978| void WhileStmtWithDeclaration(int, int) -# 978| Block 0 -# 978| v978_1(void) = EnterFunction : -# 978| mu978_2(unknown) = AliasedDefinition : -# 978| mu978_3(unknown) = UnmodeledDefinition : -# 978| r978_4(glval) = VariableAddress[x] : -# 978| m978_5(int) = InitializeParameter[x] : &:r978_4 -# 978| r978_6(glval) = VariableAddress[y] : -# 978| m978_7(int) = InitializeParameter[y] : &:r978_6 -#-----| Goto -> Block 7 - -# 979| Block 1 -# 979| v979_1(void) = NoOp : -#-----| Goto (back edge) -> Block 7 - -# 981| Block 2 -# 981| r981_1(glval) = VariableAddress[z] : -# 981| r981_2(glval) = VariableAddress[x] : -# 981| r981_3(int) = Load : &:r981_2, m978_5 -# 981| r981_4(glval) = VariableAddress[y] : -# 981| r981_5(int) = Load : &:r981_4, m978_7 -# 981| r981_6(int) = Add : r981_3, r981_5 -# 981| m981_7(int) = Store : &:r981_1, r981_6 -# 981| r981_8(glval) = VariableAddress[z] : -# 981| r981_9(int) = Load : &:r981_8, m981_7 -# 981| r981_10(int) = Constant[0] : -# 981| r981_11(bool) = CompareNE : r981_9, r981_10 -# 981| r981_12(bool) = CopyValue : r981_11 -# 981| v981_13(void) = ConditionalBranch : r981_12 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 981| Block 3 -# 981| v981_14(void) = NoOp : -#-----| Goto (back edge) -> Block 2 - -# 983| Block 4 -# 983| r983_1(glval) = VariableAddress[p] : -# 983| r983_2(glval) = VariableAddress[x] : -# 983| r983_3(int *) = CopyValue : r983_2 -# 983| m983_4(int *) = Store : &:r983_1, r983_3 -# 983| r983_5(glval) = VariableAddress[p] : -# 983| r983_6(int *) = Load : &:r983_5, m983_4 -# 983| r983_7(int *) = Constant[0] : -# 983| r983_8(bool) = CompareNE : r983_6, r983_7 -# 983| r983_9(bool) = CopyValue : r983_8 -# 983| v983_10(void) = ConditionalBranch : r983_9 -#-----| False -> Block 6 -#-----| True -> Block 5 - -# 983| Block 5 -# 983| v983_11(void) = NoOp : -#-----| Goto (back edge) -> Block 4 - -# 985| Block 6 -# 985| v985_1(void) = NoOp : -# 978| v978_8(void) = ReturnVoid : -# 978| v978_9(void) = UnmodeledUse : mu* -# 978| v978_10(void) = AliasedUse : ~mu978_3 -# 978| v978_11(void) = ExitFunction : - -# 979| Block 7 -# 979| r979_2(glval) = VariableAddress[b] : -# 979| r979_3(glval) = VariableAddress[x] : -# 979| r979_4(int) = Load : &:r979_3, m978_5 -# 979| r979_5(glval) = VariableAddress[y] : -# 979| r979_6(int) = Load : &:r979_5, m978_7 -# 979| r979_7(bool) = CompareLT : r979_4, r979_6 -# 979| m979_8(bool) = Store : &:r979_2, r979_7 -# 979| r979_9(glval) = VariableAddress[b] : -# 979| r979_10(bool) = Load : &:r979_9, m979_8 -# 979| r979_11(bool) = CopyValue : r979_10 -# 979| v979_12(void) = ConditionalBranch : r979_11 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 987| int PointerDecay(int[], int(float)) -# 987| Block 0 -# 987| v987_1(void) = EnterFunction : -# 987| mu987_2(unknown) = AliasedDefinition : -# 987| mu987_3(unknown) = UnmodeledDefinition : -# 987| r987_4(glval) = VariableAddress[a] : -# 987| m987_5(int *) = InitializeParameter[a] : &:r987_4 -# 987| r987_6(int *) = Load : &:r987_4, m987_5 -# 987| mu987_7(unknown) = InitializeIndirection[a] : &:r987_6 -# 987| r987_8(glval<..(*)(..)>) = VariableAddress[fn] : -# 987| m987_9(..(*)(..)) = InitializeParameter[fn] : &:r987_8 -# 988| r988_1(glval) = VariableAddress[#return] : -# 988| r988_2(glval) = VariableAddress[a] : -# 988| r988_3(int *) = Load : &:r988_2, m987_5 -# 988| r988_4(int) = Constant[0] : -# 988| r988_5(glval) = PointerAdd[4] : r988_3, r988_4 -# 988| r988_6(int) = Load : &:r988_5, ~mu987_3 -# 988| r988_7(glval<..(*)(..)>) = VariableAddress[fn] : -# 988| r988_8(..(*)(..)) = Load : &:r988_7, m987_9 -# 988| r988_9(float) = Constant[1.0] : -# 988| r988_10(int) = Call : func:r988_8, 0:r988_9 -# 988| mu988_11(unknown) = ^CallSideEffect : ~mu987_3 -# 988| r988_12(int) = Add : r988_6, r988_10 -# 988| m988_13(int) = Store : &:r988_1, r988_12 -# 987| v987_10(void) = ReturnIndirection : &:r987_6, ~mu987_3 -# 987| r987_11(glval) = VariableAddress[#return] : -# 987| v987_12(void) = ReturnValue : &:r987_11, m988_13 -# 987| v987_13(void) = UnmodeledUse : mu* -# 987| v987_14(void) = AliasedUse : ~mu987_3 -# 987| v987_15(void) = ExitFunction : - -# 991| int ExprStmt(int, int, int) -# 991| Block 0 -# 991| v991_1(void) = EnterFunction : -# 991| mu991_2(unknown) = AliasedDefinition : -# 991| mu991_3(unknown) = UnmodeledDefinition : -# 991| r991_4(glval) = VariableAddress[b] : -# 991| m991_5(int) = InitializeParameter[b] : &:r991_4 -# 991| r991_6(glval) = VariableAddress[y] : -# 991| m991_7(int) = InitializeParameter[y] : &:r991_6 -# 991| r991_8(glval) = VariableAddress[z] : -# 991| m991_9(int) = InitializeParameter[z] : &:r991_8 -# 992| r992_1(glval) = VariableAddress[x] : -# 993| r993_1(glval) = VariableAddress[w] : -# 993| m993_2(int) = Uninitialized[w] : &:r993_1 -# 994| r994_1(glval) = VariableAddress[b] : -# 994| r994_2(int) = Load : &:r994_1, m991_5 -# 994| r994_3(int) = Constant[0] : -# 994| r994_4(bool) = CompareNE : r994_2, r994_3 -# 994| v994_5(void) = ConditionalBranch : r994_4 -#-----| False -> Block 2 -#-----| True -> Block 1 - -# 995| Block 1 -# 995| r995_1(glval) = VariableAddress[y] : -# 995| r995_2(int) = Load : &:r995_1, m991_7 -# 995| r995_3(glval) = VariableAddress[w] : -# 995| m995_4(int) = Store : &:r995_3, r995_2 -#-----| Goto -> Block 3 - -# 997| Block 2 -# 997| r997_1(glval) = VariableAddress[z] : -# 997| r997_2(int) = Load : &:r997_1, m991_9 -# 997| r997_3(glval) = VariableAddress[w] : -# 997| m997_4(int) = Store : &:r997_3, r997_2 -#-----| Goto -> Block 3 - -# 999| Block 3 -# 999| m999_1(int) = Phi : from 1:m995_4, from 2:m997_4 -# 999| r999_2(glval) = VariableAddress[w] : -# 999| r999_3(int) = Load : &:r999_2, m999_1 -# 992| r992_2(int) = CopyValue : r999_3 -# 992| m992_3(int) = Store : &:r992_1, r992_2 -# 1002| r1002_1(glval) = VariableAddress[#return] : -# 1002| r1002_2(glval) = VariableAddress[x] : -# 1002| r1002_3(int) = Load : &:r1002_2, m992_3 -# 1002| r1002_4(int) = CopyValue : r1002_3 -# 1002| m1002_5(int) = Store : &:r1002_1, r1002_4 -# 991| r991_10(glval) = VariableAddress[#return] : -# 991| v991_11(void) = ReturnValue : &:r991_10, m1002_5 -# 991| v991_12(void) = UnmodeledUse : mu* -# 991| v991_13(void) = AliasedUse : ~mu991_3 -# 991| v991_14(void) = ExitFunction : - -# 1006| void OperatorDelete() -# 1006| Block 0 -# 1006| v1006_1(void) = EnterFunction : -# 1006| mu1006_2(unknown) = AliasedDefinition : -# 1006| mu1006_3(unknown) = UnmodeledDefinition : -# 1007| r1007_1(int *) = Constant[0] : -# 1007| v1007_2(void) = NoOp : -# 1008| r1008_1(String *) = Constant[0] : -# 1008| v1008_2(void) = NoOp : -# 1009| r1009_1(SizedDealloc *) = Constant[0] : -# 1009| v1009_2(void) = NoOp : -# 1010| r1010_1(Overaligned *) = Constant[0] : -# 1010| v1010_2(void) = NoOp : -# 1011| r1011_1(PolymorphicBase *) = Constant[0] : -# 1011| v1011_2(void) = NoOp : -# 1012| v1012_1(void) = NoOp : -# 1006| v1006_4(void) = ReturnVoid : -# 1006| v1006_5(void) = UnmodeledUse : mu* -# 1006| v1006_6(void) = AliasedUse : ~mu1006_3 -# 1006| v1006_7(void) = ExitFunction : - -# 1015| void OperatorDeleteArray() -# 1015| Block 0 -# 1015| v1015_1(void) = EnterFunction : -# 1015| mu1015_2(unknown) = AliasedDefinition : -# 1015| mu1015_3(unknown) = UnmodeledDefinition : -# 1016| r1016_1(int *) = Constant[0] : -# 1016| v1016_2(void) = NoOp : -# 1017| r1017_1(String *) = Constant[0] : -# 1017| v1017_2(void) = NoOp : -# 1018| r1018_1(SizedDealloc *) = Constant[0] : -# 1018| v1018_2(void) = NoOp : -# 1019| r1019_1(Overaligned *) = Constant[0] : -# 1019| v1019_2(void) = NoOp : -# 1020| r1020_1(PolymorphicBase *) = Constant[0] : -# 1020| v1020_2(void) = NoOp : -# 1021| v1021_1(void) = NoOp : -# 1015| v1015_4(void) = ReturnVoid : -# 1015| v1015_5(void) = UnmodeledUse : mu* -# 1015| v1015_6(void) = AliasedUse : ~mu1015_3 -# 1015| v1015_7(void) = ExitFunction : - -# 1025| void EmptyStructInit() -# 1025| Block 0 -# 1025| v1025_1(void) = EnterFunction : -# 1025| mu1025_2(unknown) = AliasedDefinition : -# 1025| mu1025_3(unknown) = UnmodeledDefinition : -# 1026| r1026_1(glval) = VariableAddress[s] : -# 1026| m1026_2(EmptyStruct) = Uninitialized[s] : &:r1026_1 -# 1027| v1027_1(void) = NoOp : -# 1025| v1025_4(void) = ReturnVoid : -# 1025| v1025_5(void) = UnmodeledUse : mu* -# 1025| v1025_6(void) = AliasedUse : ~mu1025_3 -# 1025| v1025_7(void) = ExitFunction : - -# 1029| void (lambda [] type at line 1029, col. 12)::operator()() const -# 1029| Block 0 -# 1029| v1029_1(void) = EnterFunction : -# 1029| mu1029_2(unknown) = AliasedDefinition : -# 1029| mu1029_3(unknown) = UnmodeledDefinition : -# 1029| r1029_4(glval) = InitializeThis : -# 1029| v1029_5(void) = NoOp : -# 1029| v1029_6(void) = ReturnVoid : -# 1029| v1029_7(void) = UnmodeledUse : mu* -# 1029| v1029_8(void) = AliasedUse : ~mu1029_3 -# 1029| v1029_9(void) = ExitFunction : - -# 1029| void(* (lambda [] type at line 1029, col. 12)::operator void (*)()() const)() -# 1029| Block 0 -# 1029| v1029_1(void) = EnterFunction : -# 1029| mu1029_2(unknown) = AliasedDefinition : -# 1029| mu1029_3(unknown) = UnmodeledDefinition : -# 1029| r1029_4(glval) = InitializeThis : -# 1029| r1029_5(glval<..(*)(..)>) = VariableAddress[#return] : -# 1029| r1029_6(..(*)(..)) = FunctionAddress[_FUN] : -# 1029| m1029_7(..(*)(..)) = Store : &:r1029_5, r1029_6 -# 1029| r1029_8(glval<..(*)(..)>) = VariableAddress[#return] : -# 1029| v1029_9(void) = ReturnValue : &:r1029_8, m1029_7 -# 1029| v1029_10(void) = UnmodeledUse : mu* -# 1029| v1029_11(void) = AliasedUse : ~mu1029_3 -# 1029| v1029_12(void) = ExitFunction : - -# 1031| void Lambda(int, String const&) -# 1031| Block 0 -# 1031| v1031_1(void) = EnterFunction : -# 1031| mu1031_2(unknown) = AliasedDefinition : -# 1031| mu1031_3(unknown) = UnmodeledDefinition : -# 1031| r1031_4(glval) = VariableAddress[x] : -# 1031| m1031_5(int) = InitializeParameter[x] : &:r1031_4 -# 1031| r1031_6(glval) = VariableAddress[s] : -# 1031| m1031_7(String &) = InitializeParameter[s] : &:r1031_6 -# 1031| r1031_8(String &) = Load : &:r1031_6, m1031_7 -# 1031| mu1031_9(unknown) = InitializeIndirection[s] : &:r1031_8 -# 1032| r1032_1(glval) = VariableAddress[lambda_empty] : -# 1032| r1032_2(glval) = VariableAddress[#temp1032:23] : -# 1032| m1032_3(decltype([...](...){...})) = Uninitialized[#temp1032:23] : &:r1032_2 -# 1032| r1032_4(decltype([...](...){...})) = Load : &:r1032_2, m1032_3 -# 1032| m1032_5(decltype([...](...){...})) = Store : &:r1032_1, r1032_4 -# 1033| r1033_1(char) = Constant[65] : -# 1034| r1034_1(glval) = VariableAddress[lambda_ref] : -# 1034| r1034_2(glval) = VariableAddress[#temp1034:20] : -# 1034| mu1034_3(decltype([...](...){...})) = Uninitialized[#temp1034:20] : &:r1034_2 -# 1034| r1034_4(glval) = FieldAddress[s] : r1034_2 -#-----| r0_1(glval) = VariableAddress[s] : -#-----| r0_2(String &) = Load : &:r0_1, m1031_7 -# 1034| r1034_5(glval) = CopyValue : r0_2 -# 1034| r1034_6(String &) = CopyValue : r1034_5 -# 1034| mu1034_7(String &) = Store : &:r1034_4, r1034_6 -# 1034| r1034_8(glval) = FieldAddress[x] : r1034_2 -#-----| r0_3(glval) = VariableAddress[x] : -#-----| r0_4(int &) = CopyValue : r0_3 -#-----| mu0_5(int &) = Store : &:r1034_8, r0_4 -# 1034| r1034_9(decltype([...](...){...})) = Load : &:r1034_2, ~mu1031_3 -# 1034| mu1034_10(decltype([...](...){...})) = Store : &:r1034_1, r1034_9 -# 1035| r1035_1(glval) = VariableAddress[lambda_ref] : -# 1035| r1035_2(glval) = Convert : r1035_1 -# 1035| r1035_3(glval) = FunctionAddress[operator()] : -# 1035| r1035_4(float) = Constant[1.0] : -# 1035| r1035_5(char) = Call : func:r1035_3, this:r1035_2, 0:r1035_4 -# 1035| mu1035_6(unknown) = ^CallSideEffect : ~mu1031_3 -# 1035| v1035_7(void) = ^BufferReadSideEffect[-1] : &:r1035_2, ~mu1031_3 -# 1035| mu1035_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1035_2 -# 1036| r1036_1(glval) = VariableAddress[lambda_val] : -# 1036| r1036_2(glval) = VariableAddress[#temp1036:20] : -# 1036| mu1036_3(decltype([...](...){...})) = Uninitialized[#temp1036:20] : &:r1036_2 -# 1036| r1036_4(glval) = FieldAddress[s] : r1036_2 -#-----| r0_6(glval) = FunctionAddress[String] : -#-----| v0_7(void) = Call : func:r0_6, this:r1036_4 -#-----| mu0_8(unknown) = ^CallSideEffect : ~mu1031_3 -#-----| mu0_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r1036_4 -# 1036| r1036_5(glval) = FieldAddress[x] : r1036_2 -#-----| r0_10(glval) = VariableAddress[x] : -#-----| r0_11(int) = Load : &:r0_10, m1031_5 -#-----| mu0_12(int) = Store : &:r1036_5, r0_11 -# 1036| r1036_6(decltype([...](...){...})) = Load : &:r1036_2, ~mu1031_3 -# 1036| mu1036_7(decltype([...](...){...})) = Store : &:r1036_1, r1036_6 -# 1037| r1037_1(glval) = VariableAddress[lambda_val] : -# 1037| r1037_2(glval) = Convert : r1037_1 -# 1037| r1037_3(glval) = FunctionAddress[operator()] : -# 1037| r1037_4(float) = Constant[2.0] : -# 1037| r1037_5(char) = Call : func:r1037_3, this:r1037_2, 0:r1037_4 -# 1037| mu1037_6(unknown) = ^CallSideEffect : ~mu1031_3 -# 1037| v1037_7(void) = ^BufferReadSideEffect[-1] : &:r1037_2, ~mu1031_3 -# 1037| mu1037_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1037_2 -# 1038| r1038_1(glval) = VariableAddress[lambda_ref_explicit] : -# 1038| r1038_2(glval) = VariableAddress[#temp1038:29] : -# 1038| mu1038_3(decltype([...](...){...})) = Uninitialized[#temp1038:29] : &:r1038_2 -# 1038| r1038_4(glval) = FieldAddress[s] : r1038_2 -# 1038| r1038_5(glval) = VariableAddress[s] : -# 1038| r1038_6(String &) = Load : &:r1038_5, m1031_7 -# 1038| r1038_7(glval) = CopyValue : r1038_6 -# 1038| r1038_8(String &) = CopyValue : r1038_7 -# 1038| mu1038_9(String &) = Store : &:r1038_4, r1038_8 -# 1038| r1038_10(decltype([...](...){...})) = Load : &:r1038_2, ~mu1031_3 -# 1038| mu1038_11(decltype([...](...){...})) = Store : &:r1038_1, r1038_10 -# 1039| r1039_1(glval) = VariableAddress[lambda_ref_explicit] : -# 1039| r1039_2(glval) = Convert : r1039_1 -# 1039| r1039_3(glval) = FunctionAddress[operator()] : -# 1039| r1039_4(float) = Constant[3.0] : -# 1039| r1039_5(char) = Call : func:r1039_3, this:r1039_2, 0:r1039_4 -# 1039| mu1039_6(unknown) = ^CallSideEffect : ~mu1031_3 -# 1039| v1039_7(void) = ^BufferReadSideEffect[-1] : &:r1039_2, ~mu1031_3 -# 1039| mu1039_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1039_2 -# 1040| r1040_1(glval) = VariableAddress[lambda_val_explicit] : -# 1040| r1040_2(glval) = VariableAddress[#temp1040:29] : -# 1040| m1040_3(decltype([...](...){...})) = Uninitialized[#temp1040:29] : &:r1040_2 -# 1040| r1040_4(glval) = FieldAddress[s] : r1040_2 -#-----| r0_13(glval) = FunctionAddress[String] : -#-----| v0_14(void) = Call : func:r0_13, this:r1040_4 -#-----| mu0_15(unknown) = ^CallSideEffect : ~mu1031_3 -#-----| m0_16(String) = ^IndirectMayWriteSideEffect[-1] : &:r1040_4 -# 1040| r1040_5(decltype([...](...){...})) = Load : &:r1040_2, m0_16 -# 1040| mu1040_6(decltype([...](...){...})) = Store : &:r1040_1, r1040_5 -# 1041| r1041_1(glval) = VariableAddress[lambda_val_explicit] : -# 1041| r1041_2(glval) = Convert : r1041_1 -# 1041| r1041_3(glval) = FunctionAddress[operator()] : -# 1041| r1041_4(float) = Constant[4.0] : -# 1041| r1041_5(char) = Call : func:r1041_3, this:r1041_2, 0:r1041_4 -# 1041| mu1041_6(unknown) = ^CallSideEffect : ~mu1031_3 -# 1041| v1041_7(void) = ^BufferReadSideEffect[-1] : &:r1041_2, ~mu1031_3 -# 1041| mu1041_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1041_2 -# 1042| r1042_1(glval) = VariableAddress[lambda_mixed_explicit] : -# 1042| r1042_2(glval) = VariableAddress[#temp1042:31] : -# 1042| mu1042_3(decltype([...](...){...})) = Uninitialized[#temp1042:31] : &:r1042_2 -# 1042| r1042_4(glval) = FieldAddress[s] : r1042_2 -# 1042| r1042_5(glval) = VariableAddress[s] : -# 1042| r1042_6(String &) = Load : &:r1042_5, m1031_7 -# 1042| r1042_7(glval) = CopyValue : r1042_6 -# 1042| r1042_8(String &) = CopyValue : r1042_7 -# 1042| mu1042_9(String &) = Store : &:r1042_4, r1042_8 -# 1042| r1042_10(glval) = FieldAddress[x] : r1042_2 -# 1042| r1042_11(glval) = VariableAddress[x] : -# 1042| r1042_12(int) = Load : &:r1042_11, m1031_5 -# 1042| mu1042_13(int) = Store : &:r1042_10, r1042_12 -# 1042| r1042_14(decltype([...](...){...})) = Load : &:r1042_2, ~mu1031_3 -# 1042| mu1042_15(decltype([...](...){...})) = Store : &:r1042_1, r1042_14 -# 1043| r1043_1(glval) = VariableAddress[lambda_mixed_explicit] : -# 1043| r1043_2(glval) = Convert : r1043_1 -# 1043| r1043_3(glval) = FunctionAddress[operator()] : -# 1043| r1043_4(float) = Constant[5.0] : -# 1043| r1043_5(char) = Call : func:r1043_3, this:r1043_2, 0:r1043_4 -# 1043| mu1043_6(unknown) = ^CallSideEffect : ~mu1031_3 -# 1043| v1043_7(void) = ^BufferReadSideEffect[-1] : &:r1043_2, ~mu1031_3 -# 1043| mu1043_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1043_2 -# 1044| r1044_1(glval) = VariableAddress[r] : -# 1044| r1044_2(glval) = VariableAddress[x] : -# 1044| r1044_3(int) = Load : &:r1044_2, m1031_5 -# 1044| r1044_4(int) = Constant[1] : -# 1044| r1044_5(int) = Sub : r1044_3, r1044_4 -# 1044| m1044_6(int) = Store : &:r1044_1, r1044_5 -# 1045| r1045_1(glval) = VariableAddress[lambda_inits] : -# 1045| r1045_2(glval) = VariableAddress[#temp1045:22] : -# 1045| mu1045_3(decltype([...](...){...})) = Uninitialized[#temp1045:22] : &:r1045_2 -# 1045| r1045_4(glval) = FieldAddress[s] : r1045_2 -# 1045| r1045_5(glval) = VariableAddress[s] : -# 1045| r1045_6(String &) = Load : &:r1045_5, m1031_7 -# 1045| r1045_7(glval) = CopyValue : r1045_6 -# 1045| r1045_8(String &) = CopyValue : r1045_7 -# 1045| mu1045_9(String &) = Store : &:r1045_4, r1045_8 -# 1045| r1045_10(glval) = FieldAddress[x] : r1045_2 -# 1045| r1045_11(glval) = VariableAddress[x] : -# 1045| r1045_12(int) = Load : &:r1045_11, m1031_5 -# 1045| mu1045_13(int) = Store : &:r1045_10, r1045_12 -# 1045| r1045_14(glval) = FieldAddress[i] : r1045_2 -# 1045| r1045_15(glval) = VariableAddress[x] : -# 1045| r1045_16(int) = Load : &:r1045_15, m1031_5 -# 1045| r1045_17(int) = Constant[1] : -# 1045| r1045_18(int) = Add : r1045_16, r1045_17 -# 1045| mu1045_19(int) = Store : &:r1045_14, r1045_18 -# 1045| r1045_20(glval) = FieldAddress[j] : r1045_2 -# 1045| r1045_21(glval) = VariableAddress[r] : -# 1045| r1045_22(int &) = CopyValue : r1045_21 -# 1045| mu1045_23(int &) = Store : &:r1045_20, r1045_22 -# 1045| r1045_24(decltype([...](...){...})) = Load : &:r1045_2, ~mu1031_3 -# 1045| mu1045_25(decltype([...](...){...})) = Store : &:r1045_1, r1045_24 -# 1046| r1046_1(glval) = VariableAddress[lambda_inits] : -# 1046| r1046_2(glval) = Convert : r1046_1 -# 1046| r1046_3(glval) = FunctionAddress[operator()] : -# 1046| r1046_4(float) = Constant[6.0] : -# 1046| r1046_5(char) = Call : func:r1046_3, this:r1046_2, 0:r1046_4 -# 1046| mu1046_6(unknown) = ^CallSideEffect : ~mu1031_3 -# 1046| v1046_7(void) = ^BufferReadSideEffect[-1] : &:r1046_2, ~mu1031_3 -# 1046| mu1046_8(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r1046_2 -# 1047| v1047_1(void) = NoOp : -# 1031| v1031_10(void) = ReturnIndirection : &:r1031_8, ~mu1031_3 -# 1031| v1031_11(void) = ReturnVoid : -# 1031| v1031_12(void) = UnmodeledUse : mu* -# 1031| v1031_13(void) = AliasedUse : ~mu1031_3 -# 1031| v1031_14(void) = ExitFunction : - -# 1032| char (void Lambda(int, String const&))::(lambda [] type at line 1032, col. 23)::operator()(float) const -# 1032| Block 0 -# 1032| v1032_1(void) = EnterFunction : -# 1032| mu1032_2(unknown) = AliasedDefinition : -# 1032| mu1032_3(unknown) = UnmodeledDefinition : -# 1032| r1032_4(glval) = InitializeThis : -# 1032| r1032_5(glval) = VariableAddress[f] : -# 1032| m1032_6(float) = InitializeParameter[f] : &:r1032_5 -# 1032| r1032_7(glval) = VariableAddress[#return] : -# 1032| r1032_8(char) = Constant[65] : -# 1032| m1032_9(char) = Store : &:r1032_7, r1032_8 -# 1032| r1032_10(glval) = VariableAddress[#return] : -# 1032| v1032_11(void) = ReturnValue : &:r1032_10, m1032_9 -# 1032| v1032_12(void) = UnmodeledUse : mu* -# 1032| v1032_13(void) = AliasedUse : ~mu1032_3 -# 1032| v1032_14(void) = ExitFunction : - -# 1032| char(* (void Lambda(int, String const&))::(lambda [] type at line 1032, col. 23)::operator char (*)(float)() const)(float) -# 1032| Block 0 -# 1032| v1032_1(void) = EnterFunction : -# 1032| mu1032_2(unknown) = AliasedDefinition : -# 1032| mu1032_3(unknown) = UnmodeledDefinition : -# 1032| r1032_4(glval) = InitializeThis : -# 1032| r1032_5(glval<..(*)(..)>) = VariableAddress[#return] : -# 1032| r1032_6(..(*)(..)) = FunctionAddress[_FUN] : -# 1032| m1032_7(..(*)(..)) = Store : &:r1032_5, r1032_6 -# 1032| r1032_8(glval<..(*)(..)>) = VariableAddress[#return] : -# 1032| v1032_9(void) = ReturnValue : &:r1032_8, m1032_7 -# 1032| v1032_10(void) = UnmodeledUse : mu* -# 1032| v1032_11(void) = AliasedUse : ~mu1032_3 -# 1032| v1032_12(void) = ExitFunction : - -# 1034| char (void Lambda(int, String const&))::(lambda [] type at line 1034, col. 21)::operator()(float) const -# 1034| Block 0 -# 1034| v1034_1(void) = EnterFunction : -# 1034| mu1034_2(unknown) = AliasedDefinition : -# 1034| mu1034_3(unknown) = UnmodeledDefinition : -# 1034| r1034_4(glval) = InitializeThis : -# 1034| r1034_5(glval) = VariableAddress[f] : -# 1034| m1034_6(float) = InitializeParameter[f] : &:r1034_5 -# 1034| r1034_7(glval) = VariableAddress[#return] : -#-----| r0_1(lambda [] type at line 1034, col. 21 *) = CopyValue : r1034_4 -#-----| r0_2(glval) = FieldAddress[s] : r0_1 -#-----| r0_3(String &) = Load : &:r0_2, ~mu1034_3 -# 1034| r1034_8(glval) = CopyValue : r0_3 -# 1034| r1034_9(glval) = FunctionAddress[c_str] : -# 1034| r1034_10(char *) = Call : func:r1034_9, this:r1034_8 -# 1034| mu1034_11(unknown) = ^CallSideEffect : ~mu1034_3 -# 1034| v1034_12(void) = ^BufferReadSideEffect[-1] : &:r1034_8, ~mu1034_3 -# 1034| mu1034_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r1034_8 -#-----| r0_4(lambda [] type at line 1034, col. 21 *) = CopyValue : r1034_4 -#-----| r0_5(glval) = FieldAddress[x] : r0_4 -#-----| r0_6(int &) = Load : &:r0_5, ~mu1034_3 -# 1034| r1034_14(int) = Load : &:r0_6, ~mu1034_3 -# 1034| r1034_15(glval) = PointerAdd[1] : r1034_10, r1034_14 -# 1034| r1034_16(char) = Load : &:r1034_15, ~mu1034_3 -# 1034| m1034_17(char) = Store : &:r1034_7, r1034_16 -# 1034| r1034_18(glval) = VariableAddress[#return] : -# 1034| v1034_19(void) = ReturnValue : &:r1034_18, m1034_17 -# 1034| v1034_20(void) = UnmodeledUse : mu* -# 1034| v1034_21(void) = AliasedUse : ~mu1034_3 -# 1034| v1034_22(void) = ExitFunction : - -# 1036| void (void Lambda(int, String const&))::(lambda [] type at line 1036, col. 21)::~() -# 1036| Block 0 -# 1036| v1036_1(void) = EnterFunction : -# 1036| mu1036_2(unknown) = AliasedDefinition : -# 1036| mu1036_3(unknown) = UnmodeledDefinition : -# 1036| r1036_4(glval) = InitializeThis : -#-----| v0_1(void) = NoOp : -# 1036| r1036_5(glval) = FieldAddress[s] : r1036_4 -# 1036| r1036_6(glval) = FunctionAddress[~String] : -# 1036| v1036_7(void) = Call : func:r1036_6, this:r1036_5 -# 1036| mu1036_8(unknown) = ^CallSideEffect : ~mu1036_3 -# 1036| v1036_9(void) = ReturnVoid : -# 1036| v1036_10(void) = UnmodeledUse : mu* -# 1036| v1036_11(void) = AliasedUse : ~mu1036_3 -# 1036| v1036_12(void) = ExitFunction : - -# 1036| char (void Lambda(int, String const&))::(lambda [] type at line 1036, col. 21)::operator()(float) const -# 1036| Block 0 -# 1036| v1036_1(void) = EnterFunction : -# 1036| mu1036_2(unknown) = AliasedDefinition : -# 1036| mu1036_3(unknown) = UnmodeledDefinition : -# 1036| r1036_4(glval) = InitializeThis : -# 1036| r1036_5(glval) = VariableAddress[f] : -# 1036| m1036_6(float) = InitializeParameter[f] : &:r1036_5 -# 1036| r1036_7(glval) = VariableAddress[#return] : -#-----| r0_1(lambda [] type at line 1036, col. 21 *) = CopyValue : r1036_4 -#-----| r0_2(glval) = FieldAddress[s] : r0_1 -# 1036| r1036_8(glval) = FunctionAddress[c_str] : -# 1036| r1036_9(char *) = Call : func:r1036_8, this:r0_2 -# 1036| mu1036_10(unknown) = ^CallSideEffect : ~mu1036_3 -#-----| v0_3(void) = ^BufferReadSideEffect[-1] : &:r0_2, ~mu1036_3 -#-----| mu0_4(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_2 -#-----| r0_5(lambda [] type at line 1036, col. 21 *) = CopyValue : r1036_4 -#-----| r0_6(glval) = FieldAddress[x] : r0_5 -#-----| r0_7(int) = Load : &:r0_6, ~mu1036_3 -# 1036| r1036_11(glval) = PointerAdd[1] : r1036_9, r0_7 -# 1036| r1036_12(char) = Load : &:r1036_11, ~mu1036_3 -# 1036| m1036_13(char) = Store : &:r1036_7, r1036_12 -# 1036| r1036_14(glval) = VariableAddress[#return] : -# 1036| v1036_15(void) = ReturnValue : &:r1036_14, m1036_13 -# 1036| v1036_16(void) = UnmodeledUse : mu* -# 1036| v1036_17(void) = AliasedUse : ~mu1036_3 -# 1036| v1036_18(void) = ExitFunction : - -# 1038| char (void Lambda(int, String const&))::(lambda [] type at line 1038, col. 30)::operator()(float) const -# 1038| Block 0 -# 1038| v1038_1(void) = EnterFunction : -# 1038| mu1038_2(unknown) = AliasedDefinition : -# 1038| mu1038_3(unknown) = UnmodeledDefinition : -# 1038| r1038_4(glval) = InitializeThis : -# 1038| r1038_5(glval) = VariableAddress[f] : -# 1038| m1038_6(float) = InitializeParameter[f] : &:r1038_5 -# 1038| r1038_7(glval) = VariableAddress[#return] : -#-----| r0_1(lambda [] type at line 1038, col. 30 *) = CopyValue : r1038_4 -#-----| r0_2(glval) = FieldAddress[s] : r0_1 -#-----| r0_3(String &) = Load : &:r0_2, ~mu1038_3 -# 1038| r1038_8(glval) = CopyValue : r0_3 -# 1038| r1038_9(glval) = FunctionAddress[c_str] : -# 1038| r1038_10(char *) = Call : func:r1038_9, this:r1038_8 -# 1038| mu1038_11(unknown) = ^CallSideEffect : ~mu1038_3 -# 1038| v1038_12(void) = ^BufferReadSideEffect[-1] : &:r1038_8, ~mu1038_3 -# 1038| mu1038_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r1038_8 -# 1038| r1038_14(int) = Constant[0] : -# 1038| r1038_15(glval) = PointerAdd[1] : r1038_10, r1038_14 -# 1038| r1038_16(char) = Load : &:r1038_15, ~mu1038_3 -# 1038| m1038_17(char) = Store : &:r1038_7, r1038_16 -# 1038| r1038_18(glval) = VariableAddress[#return] : -# 1038| v1038_19(void) = ReturnValue : &:r1038_18, m1038_17 -# 1038| v1038_20(void) = UnmodeledUse : mu* -# 1038| v1038_21(void) = AliasedUse : ~mu1038_3 -# 1038| v1038_22(void) = ExitFunction : - -# 1040| void (void Lambda(int, String const&))::(lambda [] type at line 1040, col. 30)::~() -# 1040| Block 0 -# 1040| v1040_1(void) = EnterFunction : -# 1040| mu1040_2(unknown) = AliasedDefinition : -# 1040| mu1040_3(unknown) = UnmodeledDefinition : -# 1040| r1040_4(glval) = InitializeThis : -#-----| v0_1(void) = NoOp : -# 1040| r1040_5(glval) = FieldAddress[s] : r1040_4 -# 1040| r1040_6(glval) = FunctionAddress[~String] : -# 1040| v1040_7(void) = Call : func:r1040_6, this:r1040_5 -# 1040| mu1040_8(unknown) = ^CallSideEffect : ~mu1040_3 -# 1040| v1040_9(void) = ReturnVoid : -# 1040| v1040_10(void) = UnmodeledUse : mu* -# 1040| v1040_11(void) = AliasedUse : ~mu1040_3 -# 1040| v1040_12(void) = ExitFunction : - -# 1040| char (void Lambda(int, String const&))::(lambda [] type at line 1040, col. 30)::operator()(float) const -# 1040| Block 0 -# 1040| v1040_1(void) = EnterFunction : -# 1040| mu1040_2(unknown) = AliasedDefinition : -# 1040| mu1040_3(unknown) = UnmodeledDefinition : -# 1040| r1040_4(glval) = InitializeThis : -# 1040| r1040_5(glval) = VariableAddress[f] : -# 1040| m1040_6(float) = InitializeParameter[f] : &:r1040_5 -# 1040| r1040_7(glval) = VariableAddress[#return] : -#-----| r0_1(lambda [] type at line 1040, col. 30 *) = CopyValue : r1040_4 -#-----| r0_2(glval) = FieldAddress[s] : r0_1 -# 1040| r1040_8(glval) = FunctionAddress[c_str] : -# 1040| r1040_9(char *) = Call : func:r1040_8, this:r0_2 -# 1040| mu1040_10(unknown) = ^CallSideEffect : ~mu1040_3 -#-----| v0_3(void) = ^BufferReadSideEffect[-1] : &:r0_2, ~mu1040_3 -#-----| mu0_4(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_2 -# 1040| r1040_11(int) = Constant[0] : -# 1040| r1040_12(glval) = PointerAdd[1] : r1040_9, r1040_11 -# 1040| r1040_13(char) = Load : &:r1040_12, ~mu1040_3 -# 1040| m1040_14(char) = Store : &:r1040_7, r1040_13 -# 1040| r1040_15(glval) = VariableAddress[#return] : -# 1040| v1040_16(void) = ReturnValue : &:r1040_15, m1040_14 -# 1040| v1040_17(void) = UnmodeledUse : mu* -# 1040| v1040_18(void) = AliasedUse : ~mu1040_3 -# 1040| v1040_19(void) = ExitFunction : - -# 1042| char (void Lambda(int, String const&))::(lambda [] type at line 1042, col. 32)::operator()(float) const -# 1042| Block 0 -# 1042| v1042_1(void) = EnterFunction : -# 1042| mu1042_2(unknown) = AliasedDefinition : -# 1042| mu1042_3(unknown) = UnmodeledDefinition : -# 1042| r1042_4(glval) = InitializeThis : -# 1042| r1042_5(glval) = VariableAddress[f] : -# 1042| m1042_6(float) = InitializeParameter[f] : &:r1042_5 -# 1042| r1042_7(glval) = VariableAddress[#return] : -#-----| r0_1(lambda [] type at line 1042, col. 32 *) = CopyValue : r1042_4 -#-----| r0_2(glval) = FieldAddress[s] : r0_1 -#-----| r0_3(String &) = Load : &:r0_2, ~mu1042_3 -# 1042| r1042_8(glval) = CopyValue : r0_3 -# 1042| r1042_9(glval) = FunctionAddress[c_str] : -# 1042| r1042_10(char *) = Call : func:r1042_9, this:r1042_8 -# 1042| mu1042_11(unknown) = ^CallSideEffect : ~mu1042_3 -# 1042| v1042_12(void) = ^BufferReadSideEffect[-1] : &:r1042_8, ~mu1042_3 -# 1042| mu1042_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r1042_8 -#-----| r0_4(lambda [] type at line 1042, col. 32 *) = CopyValue : r1042_4 -#-----| r0_5(glval) = FieldAddress[x] : r0_4 -#-----| r0_6(int) = Load : &:r0_5, ~mu1042_3 -# 1042| r1042_14(glval) = PointerAdd[1] : r1042_10, r0_6 -# 1042| r1042_15(char) = Load : &:r1042_14, ~mu1042_3 -# 1042| m1042_16(char) = Store : &:r1042_7, r1042_15 -# 1042| r1042_17(glval) = VariableAddress[#return] : -# 1042| v1042_18(void) = ReturnValue : &:r1042_17, m1042_16 -# 1042| v1042_19(void) = UnmodeledUse : mu* -# 1042| v1042_20(void) = AliasedUse : ~mu1042_3 -# 1042| v1042_21(void) = ExitFunction : - -# 1045| char (void Lambda(int, String const&))::(lambda [] type at line 1045, col. 23)::operator()(float) const -# 1045| Block 0 -# 1045| v1045_1(void) = EnterFunction : -# 1045| mu1045_2(unknown) = AliasedDefinition : -# 1045| mu1045_3(unknown) = UnmodeledDefinition : -# 1045| r1045_4(glval) = InitializeThis : -# 1045| r1045_5(glval) = VariableAddress[f] : -# 1045| m1045_6(float) = InitializeParameter[f] : &:r1045_5 -# 1045| r1045_7(glval) = VariableAddress[#return] : -#-----| r0_1(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 -#-----| r0_2(glval) = FieldAddress[s] : r0_1 -#-----| r0_3(String &) = Load : &:r0_2, ~mu1045_3 -# 1045| r1045_8(glval) = CopyValue : r0_3 -# 1045| r1045_9(glval) = FunctionAddress[c_str] : -# 1045| r1045_10(char *) = Call : func:r1045_9, this:r1045_8 -# 1045| mu1045_11(unknown) = ^CallSideEffect : ~mu1045_3 -# 1045| v1045_12(void) = ^BufferReadSideEffect[-1] : &:r1045_8, ~mu1045_3 -# 1045| mu1045_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r1045_8 -#-----| r0_4(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 -#-----| r0_5(glval) = FieldAddress[x] : r0_4 -#-----| r0_6(int) = Load : &:r0_5, ~mu1045_3 -#-----| r0_7(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 -# 1045| r1045_14(glval) = FieldAddress[i] : r0_7 -# 1045| r1045_15(int) = Load : &:r1045_14, ~mu1045_3 -# 1045| r1045_16(int) = Add : r0_6, r1045_15 -#-----| r0_8(lambda [] type at line 1045, col. 23 *) = CopyValue : r1045_4 -# 1045| r1045_17(glval) = FieldAddress[j] : r0_8 -# 1045| r1045_18(int &) = Load : &:r1045_17, ~mu1045_3 -# 1045| r1045_19(int) = Load : &:r1045_18, ~mu1045_3 -# 1045| r1045_20(int) = Sub : r1045_16, r1045_19 -# 1045| r1045_21(glval) = PointerAdd[1] : r1045_10, r1045_20 -# 1045| r1045_22(char) = Load : &:r1045_21, ~mu1045_3 -# 1045| m1045_23(char) = Store : &:r1045_7, r1045_22 -# 1045| r1045_24(glval) = VariableAddress[#return] : -# 1045| v1045_25(void) = ReturnValue : &:r1045_24, m1045_23 -# 1045| v1045_26(void) = UnmodeledUse : mu* -# 1045| v1045_27(void) = AliasedUse : ~mu1045_3 -# 1045| v1045_28(void) = ExitFunction : - -# 1068| void RangeBasedFor(vector const&) -# 1068| Block 0 -# 1068| v1068_1(void) = EnterFunction : -# 1068| mu1068_2(unknown) = AliasedDefinition : -# 1068| mu1068_3(unknown) = UnmodeledDefinition : -# 1068| r1068_4(glval &>) = VariableAddress[v] : -# 1068| m1068_5(vector &) = InitializeParameter[v] : &:r1068_4 -# 1068| r1068_6(vector &) = Load : &:r1068_4, m1068_5 -# 1068| mu1068_7(unknown) = InitializeIndirection[v] : &:r1068_6 -# 1069| r1069_1(glval &>) = VariableAddress[(__range)] : -# 1069| r1069_2(glval &>) = VariableAddress[v] : -# 1069| r1069_3(vector &) = Load : &:r1069_2, m1068_5 -# 1069| r1069_4(glval>) = CopyValue : r1069_3 -# 1069| r1069_5(vector &) = CopyValue : r1069_4 -# 1069| m1069_6(vector &) = Store : &:r1069_1, r1069_5 -# 1069| r1069_7(glval) = VariableAddress[(__begin)] : -#-----| r0_1(glval &>) = VariableAddress[(__range)] : -#-----| r0_2(vector &) = Load : &:r0_1, m1069_6 -#-----| r0_3(glval>) = CopyValue : r0_2 -# 1069| r1069_8(glval) = FunctionAddress[begin] : -# 1069| r1069_9(iterator) = Call : func:r1069_8, this:r0_3 -# 1069| mu1069_10(unknown) = ^CallSideEffect : ~mu1068_3 -#-----| v0_4(void) = ^BufferReadSideEffect[-1] : &:r0_3, ~mu1068_3 -#-----| mu0_5(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_3 -# 1069| mu1069_11(iterator) = Store : &:r1069_7, r1069_9 -# 1069| r1069_12(glval) = VariableAddress[(__end)] : -#-----| r0_6(glval &>) = VariableAddress[(__range)] : -#-----| r0_7(vector &) = Load : &:r0_6, m1069_6 -#-----| r0_8(glval>) = CopyValue : r0_7 -# 1069| r1069_13(glval) = FunctionAddress[end] : -# 1069| r1069_14(iterator) = Call : func:r1069_13, this:r0_8 -# 1069| mu1069_15(unknown) = ^CallSideEffect : ~mu1068_3 -#-----| v0_9(void) = ^BufferReadSideEffect[-1] : &:r0_8, ~mu1068_3 -#-----| mu0_10(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 -# 1069| m1069_16(iterator) = Store : &:r1069_12, r1069_14 -#-----| Goto -> Block 6 - -#-----| Block 1 -#-----| r0_11(glval) = VariableAddress[(__begin)] : -#-----| r0_12(glval) = Convert : r0_11 -# 1075| r1075_1(glval) = FunctionAddress[operator!=] : -#-----| r0_13(glval) = VariableAddress[(__end)] : -#-----| r0_14(iterator) = Load : &:r0_13, m1075_32 -# 1075| r1075_2(bool) = Call : func:r1075_1, this:r0_12, 0:r0_14 -# 1075| mu1075_3(unknown) = ^CallSideEffect : ~mu1068_3 -#-----| v0_15(void) = ^BufferReadSideEffect[-1] : &:r0_12, ~mu1068_3 -#-----| mu0_16(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_12 -# 1075| v1075_4(void) = ConditionalBranch : r1075_2 -#-----| False -> Block 5 -#-----| True -> Block 3 - -#-----| Block 2 -#-----| r0_17(glval) = VariableAddress[(__begin)] : -# 1075| r1075_5(glval) = FunctionAddress[operator++] : -# 1075| r1075_6(iterator &) = Call : func:r1075_5, this:r0_17 -# 1075| mu1075_7(unknown) = ^CallSideEffect : ~mu1068_3 -#-----| v0_18(void) = ^BufferReadSideEffect[-1] : &:r0_17, ~mu1068_3 -#-----| mu0_19(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_17 -# 1075| r1075_8(glval) = CopyValue : r1075_6 -#-----| Goto (back edge) -> Block 1 - -# 1075| Block 3 -# 1075| r1075_9(glval) = VariableAddress[e] : -#-----| r0_20(glval) = VariableAddress[(__begin)] : -#-----| r0_21(glval) = Convert : r0_20 -# 1075| r1075_10(glval) = FunctionAddress[operator*] : -# 1075| r1075_11(int &) = Call : func:r1075_10, this:r0_21 -# 1075| mu1075_12(unknown) = ^CallSideEffect : ~mu1068_3 -#-----| v0_22(void) = ^BufferReadSideEffect[-1] : &:r0_21, ~mu1068_3 -#-----| mu0_23(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_21 -# 1075| r1075_13(glval) = CopyValue : r1075_11 -# 1075| r1075_14(glval) = Convert : r1075_13 -# 1075| r1075_15(int &) = CopyValue : r1075_14 -# 1075| m1075_16(int &) = Store : &:r1075_9, r1075_15 -# 1076| r1076_1(glval) = VariableAddress[e] : -# 1076| r1076_2(int &) = Load : &:r1076_1, m1075_16 -# 1076| r1076_3(int) = Load : &:r1076_2, ~mu1068_3 -# 1076| r1076_4(int) = Constant[5] : -# 1076| r1076_5(bool) = CompareLT : r1076_3, r1076_4 -# 1076| v1076_6(void) = ConditionalBranch : r1076_5 -#-----| False -> Block 2 -#-----| True -> Block 4 - -# 1077| Block 4 -# 1077| v1077_1(void) = NoOp : -#-----| Goto -> Block 5 - -# 1079| Block 5 -# 1079| v1079_1(void) = NoOp : -# 1080| v1080_1(void) = NoOp : -# 1068| v1068_8(void) = ReturnIndirection : &:r1068_6, ~mu1068_3 -# 1068| v1068_9(void) = ReturnVoid : -# 1068| v1068_10(void) = UnmodeledUse : mu* -# 1068| v1068_11(void) = AliasedUse : ~mu1068_3 -# 1068| v1068_12(void) = ExitFunction : - -#-----| Block 6 -#-----| r0_24(glval) = VariableAddress[(__begin)] : -#-----| r0_25(glval) = Convert : r0_24 -# 1069| r1069_17(glval) = FunctionAddress[operator!=] : -#-----| r0_26(glval) = VariableAddress[(__end)] : -#-----| r0_27(iterator) = Load : &:r0_26, m1069_16 -# 1069| r1069_18(bool) = Call : func:r1069_17, this:r0_25, 0:r0_27 -# 1069| mu1069_19(unknown) = ^CallSideEffect : ~mu1068_3 -#-----| v0_28(void) = ^BufferReadSideEffect[-1] : &:r0_25, ~mu1068_3 -#-----| mu0_29(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_25 -# 1069| v1069_20(void) = ConditionalBranch : r1069_18 -#-----| False -> Block 10 -#-----| True -> Block 7 - -# 1069| Block 7 -# 1069| r1069_21(glval) = VariableAddress[e] : -#-----| r0_30(glval) = VariableAddress[(__begin)] : -#-----| r0_31(glval) = Convert : r0_30 -# 1069| r1069_22(glval) = FunctionAddress[operator*] : -# 1069| r1069_23(int &) = Call : func:r1069_22, this:r0_31 -# 1069| mu1069_24(unknown) = ^CallSideEffect : ~mu1068_3 -#-----| v0_32(void) = ^BufferReadSideEffect[-1] : &:r0_31, ~mu1068_3 -#-----| mu0_33(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_31 -# 1069| r1069_25(int) = Load : &:r1069_23, ~mu1068_3 -# 1069| m1069_26(int) = Store : &:r1069_21, r1069_25 -# 1070| r1070_1(glval) = VariableAddress[e] : -# 1070| r1070_2(int) = Load : &:r1070_1, m1069_26 -# 1070| r1070_3(int) = Constant[0] : -# 1070| r1070_4(bool) = CompareGT : r1070_2, r1070_3 -# 1070| v1070_5(void) = ConditionalBranch : r1070_4 -#-----| False -> Block 9 -#-----| True -> Block 8 - -# 1071| Block 8 -# 1071| v1071_1(void) = NoOp : -#-----| Goto -> Block 9 - -# 1069| Block 9 -# 1069| v1069_27(void) = NoOp : -#-----| r0_34(glval) = VariableAddress[(__begin)] : -# 1069| r1069_28(glval) = FunctionAddress[operator++] : -# 1069| r1069_29(iterator &) = Call : func:r1069_28, this:r0_34 -# 1069| mu1069_30(unknown) = ^CallSideEffect : ~mu1068_3 -#-----| v0_35(void) = ^BufferReadSideEffect[-1] : &:r0_34, ~mu1068_3 -#-----| mu0_36(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_34 -# 1069| r1069_31(glval) = CopyValue : r1069_29 -#-----| Goto (back edge) -> Block 6 - -# 1075| Block 10 -# 1075| r1075_17(glval &>) = VariableAddress[(__range)] : -# 1075| r1075_18(glval &>) = VariableAddress[v] : -# 1075| r1075_19(vector &) = Load : &:r1075_18, m1068_5 -# 1075| r1075_20(glval>) = CopyValue : r1075_19 -# 1075| r1075_21(vector &) = CopyValue : r1075_20 -# 1075| m1075_22(vector &) = Store : &:r1075_17, r1075_21 -# 1075| r1075_23(glval) = VariableAddress[(__begin)] : -#-----| r0_37(glval &>) = VariableAddress[(__range)] : -#-----| r0_38(vector &) = Load : &:r0_37, m1075_22 -#-----| r0_39(glval>) = CopyValue : r0_38 -# 1075| r1075_24(glval) = FunctionAddress[begin] : -# 1075| r1075_25(iterator) = Call : func:r1075_24, this:r0_39 -# 1075| mu1075_26(unknown) = ^CallSideEffect : ~mu1068_3 -#-----| v0_40(void) = ^BufferReadSideEffect[-1] : &:r0_39, ~mu1068_3 -#-----| mu0_41(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_39 -# 1075| mu1075_27(iterator) = Store : &:r1075_23, r1075_25 -# 1075| r1075_28(glval) = VariableAddress[(__end)] : -#-----| r0_42(glval &>) = VariableAddress[(__range)] : -#-----| r0_43(vector &) = Load : &:r0_42, m1075_22 -#-----| r0_44(glval>) = CopyValue : r0_43 -# 1075| r1075_29(glval) = FunctionAddress[end] : -# 1075| r1075_30(iterator) = Call : func:r1075_29, this:r0_44 -# 1075| mu1075_31(unknown) = ^CallSideEffect : ~mu1068_3 -#-----| v0_45(void) = ^BufferReadSideEffect[-1] : &:r0_44, ~mu1068_3 -#-----| mu0_46(vector) = ^IndirectMayWriteSideEffect[-1] : &:r0_44 -# 1075| m1075_32(iterator) = Store : &:r1075_28, r1075_30 -#-----| Goto -> Block 1 - -# 1099| int AsmStmt(int) -# 1099| Block 0 -# 1099| v1099_1(void) = EnterFunction : -# 1099| mu1099_2(unknown) = AliasedDefinition : -# 1099| mu1099_3(unknown) = UnmodeledDefinition : -# 1099| r1099_4(glval) = VariableAddress[x] : -# 1099| m1099_5(int) = InitializeParameter[x] : &:r1099_4 -# 1100| mu1100_1(unknown) = InlineAsm : ~mu1099_3 -# 1101| r1101_1(glval) = VariableAddress[#return] : -# 1101| r1101_2(glval) = VariableAddress[x] : -# 1101| r1101_3(int) = Load : &:r1101_2, m1099_5 -# 1101| m1101_4(int) = Store : &:r1101_1, r1101_3 -# 1099| r1099_6(glval) = VariableAddress[#return] : -# 1099| v1099_7(void) = ReturnValue : &:r1099_6, m1101_4 -# 1099| v1099_8(void) = UnmodeledUse : mu* -# 1099| v1099_9(void) = AliasedUse : ~mu1099_3 -# 1099| v1099_10(void) = ExitFunction : - -# 1104| void AsmStmtWithOutputs(unsigned int&, unsigned int, unsigned int&, unsigned int) -# 1104| Block 0 -# 1104| v1104_1(void) = EnterFunction : -# 1104| mu1104_2(unknown) = AliasedDefinition : -# 1104| mu1104_3(unknown) = UnmodeledDefinition : -# 1104| r1104_4(glval) = VariableAddress[a] : -# 1104| m1104_5(unsigned int &) = InitializeParameter[a] : &:r1104_4 -# 1104| r1104_6(unsigned int &) = Load : &:r1104_4, m1104_5 -# 1104| mu1104_7(unknown) = InitializeIndirection[a] : &:r1104_6 -# 1104| r1104_8(glval) = VariableAddress[b] : -# 1104| m1104_9(unsigned int) = InitializeParameter[b] : &:r1104_8 -# 1104| r1104_10(glval) = VariableAddress[c] : -# 1104| m1104_11(unsigned int &) = InitializeParameter[c] : &:r1104_10 -# 1104| r1104_12(unsigned int &) = Load : &:r1104_10, m1104_11 -# 1104| mu1104_13(unknown) = InitializeIndirection[c] : &:r1104_12 -# 1104| r1104_14(glval) = VariableAddress[d] : -# 1104| m1104_15(unsigned int) = InitializeParameter[d] : &:r1104_14 -# 1109| r1109_1(glval) = VariableAddress[a] : -# 1109| r1109_2(unsigned int &) = Load : &:r1109_1, m1104_5 -# 1109| r1109_3(glval) = CopyValue : r1109_2 -# 1109| r1109_4(glval) = VariableAddress[b] : -# 1109| r1109_5(glval) = VariableAddress[c] : -# 1109| r1109_6(unsigned int &) = Load : &:r1109_5, m1104_11 -# 1109| r1109_7(unsigned int) = Load : &:r1109_6, ~mu1104_3 -# 1109| r1109_8(glval) = VariableAddress[d] : -# 1109| r1109_9(unsigned int) = Load : &:r1109_8, m1104_15 -# 1106| mu1106_1(unknown) = InlineAsm : ~mu1104_3, 0:r1109_3, 1:r1109_4, 2:r1109_7, 3:r1109_9 -# 1111| v1111_1(void) = NoOp : -# 1104| v1104_16(void) = ReturnIndirection : &:r1104_6, ~mu1104_3 -# 1104| v1104_17(void) = ReturnIndirection : &:r1104_12, ~mu1104_3 -# 1104| v1104_18(void) = ReturnVoid : -# 1104| v1104_19(void) = UnmodeledUse : mu* -# 1104| v1104_20(void) = AliasedUse : ~mu1104_3 -# 1104| v1104_21(void) = ExitFunction : - -# 1113| void ExternDeclarations() -# 1113| Block 0 -# 1113| v1113_1(void) = EnterFunction : -# 1113| mu1113_2(unknown) = AliasedDefinition : -# 1113| mu1113_3(unknown) = UnmodeledDefinition : -# 1116| r1116_1(glval) = VariableAddress[x] : -# 1116| m1116_2(int) = Uninitialized[x] : &:r1116_1 -# 1117| r1117_1(glval) = VariableAddress[y] : -# 1117| m1117_2(int) = Uninitialized[y] : &:r1117_1 -# 1118| r1118_1(glval) = VariableAddress[h] : -# 1118| m1118_2(int) = Uninitialized[h] : &:r1118_1 -# 1120| v1120_1(void) = NoOp : -# 1113| v1113_4(void) = ReturnVoid : -# 1113| v1113_5(void) = UnmodeledUse : mu* -# 1113| v1113_6(void) = AliasedUse : ~mu1113_3 -# 1113| v1113_7(void) = ExitFunction : - -# 1128| void ExternDeclarationsInMacro() -# 1128| Block 0 -# 1128| v1128_1(void) = EnterFunction : -# 1128| mu1128_2(unknown) = AliasedDefinition : -# 1128| mu1128_3(unknown) = UnmodeledDefinition : -# 1130| r1130_1(glval) = VariableAddress[i] : -# 1130| r1130_2(int) = Constant[0] : -# 1130| m1130_3(int) = Store : &:r1130_1, r1130_2 -#-----| Goto -> Block 1 - -# 1130| Block 1 -# 1130| m1130_4(int) = Phi : from 0:m1130_3, from 2:m1130_14 -# 1130| r1130_5(glval) = VariableAddress[i] : -# 1130| r1130_6(int) = Load : &:r1130_5, m1130_4 -# 1130| r1130_7(int) = Constant[10] : -# 1130| r1130_8(bool) = CompareLT : r1130_6, r1130_7 -# 1130| v1130_9(void) = ConditionalBranch : r1130_8 -#-----| False -> Block 3 -#-----| True -> Block 2 - -# 1130| Block 2 -# 1130| r1130_10(glval) = VariableAddress[i] : -# 1130| r1130_11(int) = Load : &:r1130_10, m1130_4 -# 1130| r1130_12(int) = Constant[1] : -# 1130| r1130_13(int) = Add : r1130_11, r1130_12 -# 1130| m1130_14(int) = Store : &:r1130_10, r1130_13 -#-----| Goto (back edge) -> Block 1 - -# 1130| Block 3 -# 1130| v1130_15(void) = NoOp : -# 1131| v1131_1(void) = NoOp : -# 1128| v1128_4(void) = ReturnVoid : -# 1128| v1128_5(void) = UnmodeledUse : mu* -# 1128| v1128_6(void) = AliasedUse : ~mu1128_3 -# 1128| v1128_7(void) = ExitFunction : - -# 1133| void TryCatchNoCatchAny(bool) -# 1133| Block 0 -# 1133| v1133_1(void) = EnterFunction : -# 1133| mu1133_2(unknown) = AliasedDefinition : -# 1133| mu1133_3(unknown) = UnmodeledDefinition : -# 1133| r1133_4(glval) = VariableAddress[b] : -# 1133| m1133_5(bool) = InitializeParameter[b] : &:r1133_4 -# 1135| r1135_1(glval) = VariableAddress[x] : -# 1135| r1135_2(int) = Constant[5] : -# 1135| m1135_3(int) = Store : &:r1135_1, r1135_2 -# 1136| r1136_1(glval) = VariableAddress[b] : -# 1136| r1136_2(bool) = Load : &:r1136_1, m1133_5 -# 1136| v1136_3(void) = ConditionalBranch : r1136_2 -#-----| False -> Block 4 -#-----| True -> Block 3 - -# 1133| Block 1 -# 1133| v1133_6(void) = UnmodeledUse : mu* -# 1133| v1133_7(void) = AliasedUse : ~mu1133_3 -# 1133| v1133_8(void) = ExitFunction : - -# 1133| Block 2 -# 1133| v1133_9(void) = Unwind : -#-----| Goto -> Block 1 - -# 1137| Block 3 -# 1137| r1137_1(glval) = VariableAddress[#throw1137:7] : -# 1137| r1137_2(glval) = StringConstant["string literal"] : -# 1137| r1137_3(char *) = Convert : r1137_2 -# 1137| m1137_4(char *) = Store : &:r1137_1, r1137_3 -# 1137| v1137_5(void) = ThrowValue : &:r1137_1, m1137_4 -#-----| Exception -> Block 9 - -# 1139| Block 4 -# 1139| r1139_1(glval) = VariableAddress[x] : -# 1139| r1139_2(int) = Load : &:r1139_1, m1135_3 -# 1139| r1139_3(int) = Constant[2] : -# 1139| r1139_4(bool) = CompareLT : r1139_2, r1139_3 -# 1139| v1139_5(void) = ConditionalBranch : r1139_4 -#-----| False -> Block 8 -#-----| True -> Block 5 - -# 1140| Block 5 -# 1140| r1140_1(glval) = VariableAddress[b] : -# 1140| r1140_2(bool) = Load : &:r1140_1, m1133_5 -# 1140| v1140_3(void) = ConditionalBranch : r1140_2 -#-----| False -> Block 7 -#-----| True -> Block 6 - -# 1140| Block 6 -# 1140| r1140_4(int) = Constant[7] : -# 1140| r1140_5(glval) = VariableAddress[#temp1140:11] : -# 1140| m1140_6(int) = Store : &:r1140_5, r1140_4 -# 1140| r1140_7(glval) = VariableAddress[#temp1140:11] : -# 1140| r1140_8(int) = Load : &:r1140_7, m1140_6 -# 1140| r1140_9(glval) = VariableAddress[x] : -# 1140| m1140_10(int) = Store : &:r1140_9, r1140_8 -#-----| Goto -> Block 8 - -# 1140| Block 7 -# 1140| r1140_11(glval) = VariableAddress[#throw1140:19] : -# 1140| m1140_12(String) = Uninitialized[#throw1140:19] : &:r1140_11 -# 1140| r1140_13(glval) = FunctionAddress[String] : -# 1140| r1140_14(glval) = StringConstant["String object"] : -# 1140| r1140_15(char *) = Convert : r1140_14 -# 1140| v1140_16(void) = Call : func:r1140_13, this:r1140_11, 0:r1140_15 -# 1140| mu1140_17(unknown) = ^CallSideEffect : ~mu1133_3 -# 1140| m1140_18(String) = ^IndirectMayWriteSideEffect[-1] : &:r1140_11 -# 1140| v1140_19(void) = ^BufferReadSideEffect[0] : &:r1140_15, ~mu1133_3 -# 1140| mu1140_20(unknown) = ^BufferMayWriteSideEffect[0] : &:r1140_15 -# 1140| v1140_21(void) = ThrowValue : &:r1140_11, m1140_18 -#-----| Exception -> Block 9 - -# 1142| Block 8 -# 1142| r1142_1(int) = Constant[7] : -# 1142| r1142_2(glval) = VariableAddress[x] : -# 1142| m1142_3(int) = Store : &:r1142_2, r1142_1 -#-----| Goto -> Block 13 - -# 1144| Block 9 -# 1144| v1144_1(void) = CatchByType[const char *] : -#-----| Exception -> Block 11 -#-----| Goto -> Block 10 - -# 1144| Block 10 -# 1144| r1144_2(glval) = VariableAddress[s] : -# 1144| m1144_3(char *) = InitializeParameter[s] : &:r1144_2 -# 1144| r1144_4(char *) = Load : &:r1144_2, m1144_3 -# 1144| mu1144_5(unknown) = InitializeIndirection[s] : &:r1144_4 -# 1145| r1145_1(glval) = VariableAddress[#throw1145:5] : -# 1145| m1145_2(String) = Uninitialized[#throw1145:5] : &:r1145_1 -# 1145| r1145_3(glval) = FunctionAddress[String] : -# 1145| r1145_4(glval) = VariableAddress[s] : -# 1145| r1145_5(char *) = Load : &:r1145_4, m1144_3 -# 1145| v1145_6(void) = Call : func:r1145_3, this:r1145_1, 0:r1145_5 -# 1145| mu1145_7(unknown) = ^CallSideEffect : ~mu1133_3 -# 1145| m1145_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r1145_1 -# 1145| v1145_9(void) = ^BufferReadSideEffect[0] : &:r1145_5, ~mu1133_3 -# 1145| mu1145_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r1145_5 -# 1145| v1145_11(void) = ThrowValue : &:r1145_1, m1145_8 -#-----| Exception -> Block 2 - -# 1147| Block 11 -# 1147| v1147_1(void) = CatchByType[const String &] : -#-----| Exception -> Block 2 -#-----| Goto -> Block 12 - -# 1147| Block 12 -# 1147| r1147_2(glval) = VariableAddress[e] : -# 1147| m1147_3(String &) = InitializeParameter[e] : &:r1147_2 -# 1147| r1147_4(String &) = Load : &:r1147_2, m1147_3 -# 1147| mu1147_5(unknown) = InitializeIndirection[e] : &:r1147_4 -# 1147| v1147_6(void) = NoOp : -#-----| Goto -> Block 13 - -# 1149| Block 13 -# 1149| v1149_1(void) = NoOp : -# 1133| v1133_10(void) = ReturnVoid : -#-----| Goto -> Block 1 - -# 1153| void VectorTypes(int) -# 1153| Block 0 -# 1153| v1153_1(void) = EnterFunction : -# 1153| mu1153_2(unknown) = AliasedDefinition : -# 1153| mu1153_3(unknown) = UnmodeledDefinition : -# 1153| r1153_4(glval) = VariableAddress[i] : -# 1153| m1153_5(int) = InitializeParameter[i] : &:r1153_4 -# 1154| r1154_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1154| mu1154_2(__attribute((vector_size(16UL))) int) = Uninitialized[vi4] : &:r1154_1 -# 1154| r1154_3(int) = Constant[0] : -# 1154| r1154_4(glval) = PointerAdd[4] : r1154_1, r1154_3 -# 1154| r1154_5(int) = Constant[0] : -# 1154| mu1154_6(int) = Store : &:r1154_4, r1154_5 -# 1154| r1154_7(int) = Constant[1] : -# 1154| r1154_8(glval) = PointerAdd[4] : r1154_1, r1154_7 -# 1154| r1154_9(int) = Constant[1] : -# 1154| mu1154_10(int) = Store : &:r1154_8, r1154_9 -# 1154| r1154_11(int) = Constant[2] : -# 1154| r1154_12(glval) = PointerAdd[4] : r1154_1, r1154_11 -# 1154| r1154_13(int) = Constant[2] : -# 1154| mu1154_14(int) = Store : &:r1154_12, r1154_13 -# 1154| r1154_15(int) = Constant[3] : -# 1154| r1154_16(glval) = PointerAdd[4] : r1154_1, r1154_15 -# 1154| r1154_17(int) = Constant[3] : -# 1154| mu1154_18(int) = Store : &:r1154_16, r1154_17 -# 1155| r1155_1(glval) = VariableAddress[x] : -# 1155| r1155_2(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1155| r1155_3(glval) = VariableAddress[i] : -# 1155| r1155_4(int) = Load : &:r1155_3, m1153_5 -# 1155| r1155_5(glval) = PointerAdd[4] : r1155_2, r1155_4 -# 1155| r1155_6(int) = Load : &:r1155_5, ~mu1153_3 -# 1155| m1155_7(int) = Store : &:r1155_1, r1155_6 -# 1156| r1156_1(glval) = VariableAddress[x] : -# 1156| r1156_2(int) = Load : &:r1156_1, m1155_7 -# 1156| r1156_3(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1156| r1156_4(glval) = VariableAddress[i] : -# 1156| r1156_5(int) = Load : &:r1156_4, m1153_5 -# 1156| r1156_6(glval) = PointerAdd[4] : r1156_3, r1156_5 -# 1156| mu1156_7(int) = Store : &:r1156_6, r1156_2 -# 1157| r1157_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4_shuffle] : -# 1157| r1157_2(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1157| r1157_3(__attribute((vector_size(16UL))) int) = Load : &:r1157_2, ~mu1153_3 -# 1157| r1157_4(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1157| r1157_5(__attribute((vector_size(16UL))) int) = Load : &:r1157_4, ~mu1153_3 -#-----| r0_1(int) = Constant[3] : -# 1157| r1157_6(int) = Constant[2] : -# 1157| r1157_7(int) = Constant[1] : -# 1157| r1157_8(int) = Constant[0] : -# 1157| r1157_9(__attribute((vector_size(16))) int) = BuiltIn[__builtin_shufflevector] : 0:r1157_3, 1:r1157_5, 2:r0_1, 3:r1157_6, 4:r1157_7, 5:r1157_8 -# 1157| m1157_10(__attribute((vector_size(16UL))) int) = Store : &:r1157_1, r1157_9 -# 1158| r1158_1(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1158| r1158_2(__attribute((vector_size(16UL))) int) = Load : &:r1158_1, ~mu1153_3 -# 1158| r1158_3(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4_shuffle] : -# 1158| r1158_4(__attribute((vector_size(16UL))) int) = Load : &:r1158_3, m1157_10 -# 1158| r1158_5(__attribute((vector_size(16UL))) int) = Add : r1158_2, r1158_4 -# 1158| r1158_6(glval<__attribute((vector_size(16UL))) int>) = VariableAddress[vi4] : -# 1158| mu1158_7(__attribute((vector_size(16UL))) int) = Store : &:r1158_6, r1158_5 -# 1159| v1159_1(void) = NoOp : -# 1153| v1153_6(void) = ReturnVoid : -# 1153| v1153_7(void) = UnmodeledUse : mu* -# 1153| v1153_8(void) = AliasedUse : ~mu1153_3 -# 1153| v1153_9(void) = ExitFunction : - -# 1163| int ModeledCallTarget(int) -# 1163| Block 0 -# 1163| v1163_1(void) = EnterFunction : -# 1163| mu1163_2(unknown) = AliasedDefinition : -# 1163| mu1163_3(unknown) = UnmodeledDefinition : -# 1163| r1163_4(glval) = VariableAddress[x] : -# 1163| mu1163_5(int) = InitializeParameter[x] : &:r1163_4 -# 1164| r1164_1(glval) = VariableAddress[y] : -# 1164| mu1164_2(int) = Uninitialized[y] : &:r1164_1 -# 1165| r1165_1(glval) = FunctionAddress[memcpy] : -# 1165| r1165_2(glval) = VariableAddress[y] : -# 1165| r1165_3(int *) = CopyValue : r1165_2 -# 1165| r1165_4(void *) = Convert : r1165_3 -# 1165| r1165_5(glval) = VariableAddress[x] : -# 1165| r1165_6(int *) = CopyValue : r1165_5 -# 1165| r1165_7(void *) = Convert : r1165_6 -# 1165| r1165_8(int) = Constant[4] : -# 1165| r1165_9(void *) = Call : func:r1165_1, 0:r1165_4, 1:r1165_7, 2:r1165_8 -# 1165| v1165_10(void) = ^SizedBufferReadSideEffect[1] : &:r1165_7, r1165_8, ~mu1163_3 -# 1165| mu1165_11(unknown) = ^SizedBufferMustWriteSideEffect[0] : &:r1165_4, r1165_8 -# 1166| r1166_1(glval) = VariableAddress[#return] : -# 1166| r1166_2(glval) = VariableAddress[y] : -# 1166| r1166_3(int) = Load : &:r1166_2, ~mu1163_3 -# 1166| m1166_4(int) = Store : &:r1166_1, r1166_3 -# 1163| r1163_6(glval) = VariableAddress[#return] : -# 1163| v1163_7(void) = ReturnValue : &:r1163_6, m1166_4 -# 1163| v1163_8(void) = UnmodeledUse : mu* -# 1163| v1163_9(void) = AliasedUse : ~mu1163_3 -# 1163| v1163_10(void) = ExitFunction : - -# 1169| String ReturnObjectImpl() -# 1169| Block 0 -# 1169| v1169_1(void) = EnterFunction : -# 1169| mu1169_2(unknown) = AliasedDefinition : -# 1169| mu1169_3(unknown) = UnmodeledDefinition : -# 1170| r1170_1(glval) = VariableAddress[#return] : -# 1170| m1170_2(String) = Uninitialized[#return] : &:r1170_1 -# 1170| r1170_3(glval) = FunctionAddress[String] : -# 1170| r1170_4(glval) = StringConstant["foo"] : -# 1170| r1170_5(char *) = Convert : r1170_4 -# 1170| r1170_6(String) = Call : func:r1170_3, this:r1170_1, 0:r1170_5 -# 1170| mu1170_7(unknown) = ^CallSideEffect : ~mu1169_3 -# 1170| m1170_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r1170_1 -# 1170| v1170_9(void) = ^BufferReadSideEffect[0] : &:r1170_5, ~mu1169_3 -# 1170| mu1170_10(unknown) = ^BufferMayWriteSideEffect[0] : &:r1170_5 -# 1169| r1169_4(glval) = VariableAddress[#return] : -# 1169| v1169_5(void) = ReturnValue : &:r1169_4, m1170_8 -# 1169| v1169_6(void) = UnmodeledUse : mu* -# 1169| v1169_7(void) = AliasedUse : ~mu1169_3 -# 1169| v1169_8(void) = ExitFunction : - -perf-regression.cpp: -# 6| void Big::Big() -# 6| Block 0 -# 6| v6_1(void) = EnterFunction : -# 6| mu6_2(unknown) = AliasedDefinition : -# 6| mu6_3(unknown) = UnmodeledDefinition : -# 6| r6_4(glval) = InitializeThis : -# 6| r6_5(glval) = FieldAddress[buffer] : r6_4 -# 6| r6_6(int) = Constant[0] : -# 6| r6_7(glval) = PointerAdd[1] : r6_5, r6_6 -# 6| r6_8(unknown[1073741824]) = Constant[0] : -# 6| mu6_9(unknown[1073741824]) = Store : &:r6_7, r6_8 -# 6| v6_10(void) = NoOp : -# 6| v6_11(void) = ReturnVoid : -# 6| v6_12(void) = UnmodeledUse : mu* -# 6| v6_13(void) = AliasedUse : ~mu6_3 -# 6| v6_14(void) = ExitFunction : - -# 9| int main() -# 9| Block 0 -# 9| v9_1(void) = EnterFunction : -# 9| mu9_2(unknown) = AliasedDefinition : -# 9| mu9_3(unknown) = UnmodeledDefinition : -# 10| r10_1(glval) = VariableAddress[big] : -# 10| r10_2(glval) = FunctionAddress[operator new] : -# 10| r10_3(unsigned long) = Constant[1073741824] : -# 10| r10_4(void *) = Call : func:r10_2, 0:r10_3 -# 10| mu10_5(unknown) = ^CallSideEffect : ~mu9_3 -# 10| r10_6(Big *) = Convert : r10_4 -# 10| r10_7(glval) = FunctionAddress[Big] : -# 10| v10_8(void) = Call : func:r10_7, this:r10_6 -# 10| mu10_9(unknown) = ^CallSideEffect : ~mu9_3 -# 10| mu10_10(Big) = ^IndirectMayWriteSideEffect[-1] : &:r10_6 -# 10| m10_11(Big *) = Store : &:r10_1, r10_6 -# 12| r12_1(glval) = VariableAddress[#return] : -# 12| r12_2(int) = Constant[0] : -# 12| m12_3(int) = Store : &:r12_1, r12_2 -# 9| r9_4(glval) = VariableAddress[#return] : -# 9| v9_5(void) = ReturnValue : &:r9_4, m12_3 -# 9| v9_6(void) = UnmodeledUse : mu* -# 9| v9_7(void) = AliasedUse : ~mu9_3 -# 9| v9_8(void) = ExitFunction : diff --git a/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.qlref b/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.qlref deleted file mode 100644 index 3f776444036..00000000000 --- a/cpp/ql/test/library-tests/ir/ir/unaliased_ssa_ir.qlref +++ /dev/null @@ -1 +0,0 @@ -semmle/code/cpp/ir/implementation/unaliased_ssa/PrintIR.ql \ No newline at end of file From 40952f85a9ec337bbc8e597e5f3e8493888c327f Mon Sep 17 00:00:00 2001 From: Dave Bartolomeo Date: Mon, 27 Jan 2020 10:31:18 -0700 Subject: [PATCH 5/6] C++: Accept test diffs --- .../test/library-tests/dataflow/taint-tests/test_diff.expected | 1 - cpp/ql/test/library-tests/dataflow/taint-tests/test_ir.expected | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/cpp/ql/test/library-tests/dataflow/taint-tests/test_diff.expected b/cpp/ql/test/library-tests/dataflow/taint-tests/test_diff.expected index 1b05521ffc5..81d893aebd3 100644 --- a/cpp/ql/test/library-tests/dataflow/taint-tests/test_diff.expected +++ b/cpp/ql/test/library-tests/dataflow/taint-tests/test_diff.expected @@ -27,7 +27,6 @@ | taint.cpp:423:7:423:7 | taint.cpp:422:14:422:19 | AST only | | taint.cpp:424:9:424:17 | taint.cpp:422:14:422:19 | AST only | | taint.cpp:429:7:429:7 | taint.cpp:428:13:428:18 | IR only | -| taint.cpp:430:9:430:14 | taint.cpp:428:13:428:18 | AST only | | taint.cpp:438:7:438:7 | taint.cpp:437:15:437:20 | AST only | | taint.cpp:439:10:439:18 | taint.cpp:437:15:437:20 | AST only | | taint.cpp:446:7:446:7 | taint.cpp:445:14:445:28 | AST only | diff --git a/cpp/ql/test/library-tests/dataflow/taint-tests/test_ir.expected b/cpp/ql/test/library-tests/dataflow/taint-tests/test_ir.expected index ceeeba9b76c..06010367fd7 100644 --- a/cpp/ql/test/library-tests/dataflow/taint-tests/test_ir.expected +++ b/cpp/ql/test/library-tests/dataflow/taint-tests/test_ir.expected @@ -18,3 +18,4 @@ | taint.cpp:337:7:337:7 | t | taint.cpp:330:6:330:11 | call to source | | taint.cpp:350:7:350:7 | t | taint.cpp:330:6:330:11 | call to source | | taint.cpp:429:7:429:7 | b | taint.cpp:428:13:428:18 | call to source | +| taint.cpp:430:9:430:14 | member | taint.cpp:428:13:428:18 | call to source | From 7df3cf4c2312d2d17fd4f4ca8804e68def626582 Mon Sep 17 00:00:00 2001 From: Dave Bartolomeo Date: Mon, 27 Jan 2020 13:48:43 -0700 Subject: [PATCH 6/6] C++: Accept more test output after merge --- .../ir/ssa/aliased_ssa_ir_unsound.expected | 15 +++++++++------ .../ir/ssa/unaliased_ssa_ir_unsound.expected | 15 +++++++++------ 2 files changed, 18 insertions(+), 12 deletions(-) diff --git a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir_unsound.expected b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir_unsound.expected index 6846661b665..b1a174f2b0b 100644 --- a/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir_unsound.expected +++ b/cpp/ql/test/library-tests/ir/ssa/aliased_ssa_ir_unsound.expected @@ -847,23 +847,26 @@ ssa.cpp: # 199| r199_8(char *) = Convert : r199_7 # 199| r199_9(int) = Call : func:r199_2, 0:r199_5, 1:r199_8 # 199| v199_10(void) = ^CallReadSideEffect : ~m198_13 -# 199| m199_11(int) = Store : &:r199_1, r199_9 +# 199| v199_11(void) = ^BufferReadSideEffect[0] : &:r199_5, ~m198_13 +# 199| v199_12(void) = ^BufferReadSideEffect[1] : &:r199_8, ~m198_13 +# 199| m199_13(int) = Store : &:r199_1, r199_9 # 200| r200_1(glval) = FunctionAddress[strlen] : # 200| r200_2(glval) = VariableAddress[str1] : # 200| r200_3(char *) = Load : &:r200_2, m198_5 # 200| r200_4(char *) = Convert : r200_3 # 200| r200_5(int) = Call : func:r200_1, 0:r200_4 # 200| v200_6(void) = ^CallReadSideEffect : ~m198_13 -# 200| r200_7(glval) = VariableAddress[ret] : -# 200| r200_8(int) = Load : &:r200_7, m199_11 -# 200| r200_9(int) = Add : r200_8, r200_5 -# 200| m200_10(int) = Store : &:r200_7, r200_9 +# 200| v200_7(void) = ^BufferReadSideEffect[0] : &:r200_4, ~m198_13 +# 200| r200_8(glval) = VariableAddress[ret] : +# 200| r200_9(int) = Load : &:r200_8, m199_13 +# 200| r200_10(int) = Add : r200_9, r200_5 +# 200| m200_11(int) = Store : &:r200_8, r200_10 # 201| r201_1(glval) = FunctionAddress[abs] : # 201| r201_2(glval) = VariableAddress[x] : # 201| r201_3(int) = Load : &:r201_2, m198_15 # 201| r201_4(int) = Call : func:r201_1, 0:r201_3 # 201| r201_5(glval) = VariableAddress[ret] : -# 201| r201_6(int) = Load : &:r201_5, m200_10 +# 201| r201_6(int) = Load : &:r201_5, m200_11 # 201| r201_7(int) = Add : r201_6, r201_4 # 201| m201_8(int) = Store : &:r201_5, r201_7 # 202| r202_1(glval) = VariableAddress[#return] : diff --git a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir_unsound.expected b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir_unsound.expected index 5ea397b91dc..83021d91c9c 100644 --- a/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir_unsound.expected +++ b/cpp/ql/test/library-tests/ir/ssa/unaliased_ssa_ir_unsound.expected @@ -808,23 +808,26 @@ ssa.cpp: # 199| r199_8(char *) = Convert : r199_7 # 199| r199_9(int) = Call : func:r199_2, 0:r199_5, 1:r199_8 # 199| v199_10(void) = ^CallReadSideEffect : ~mu198_3 -# 199| m199_11(int) = Store : &:r199_1, r199_9 +# 199| v199_11(void) = ^BufferReadSideEffect[0] : &:r199_5, ~mu198_3 +# 199| v199_12(void) = ^BufferReadSideEffect[1] : &:r199_8, ~mu198_3 +# 199| m199_13(int) = Store : &:r199_1, r199_9 # 200| r200_1(glval) = FunctionAddress[strlen] : # 200| r200_2(glval) = VariableAddress[str1] : # 200| r200_3(char *) = Load : &:r200_2, m198_5 # 200| r200_4(char *) = Convert : r200_3 # 200| r200_5(int) = Call : func:r200_1, 0:r200_4 # 200| v200_6(void) = ^CallReadSideEffect : ~mu198_3 -# 200| r200_7(glval) = VariableAddress[ret] : -# 200| r200_8(int) = Load : &:r200_7, m199_11 -# 200| r200_9(int) = Add : r200_8, r200_5 -# 200| m200_10(int) = Store : &:r200_7, r200_9 +# 200| v200_7(void) = ^BufferReadSideEffect[0] : &:r200_4, ~mu198_3 +# 200| r200_8(glval) = VariableAddress[ret] : +# 200| r200_9(int) = Load : &:r200_8, m199_13 +# 200| r200_10(int) = Add : r200_9, r200_5 +# 200| m200_11(int) = Store : &:r200_8, r200_10 # 201| r201_1(glval) = FunctionAddress[abs] : # 201| r201_2(glval) = VariableAddress[x] : # 201| r201_3(int) = Load : &:r201_2, m198_13 # 201| r201_4(int) = Call : func:r201_1, 0:r201_3 # 201| r201_5(glval) = VariableAddress[ret] : -# 201| r201_6(int) = Load : &:r201_5, m200_10 +# 201| r201_6(int) = Load : &:r201_5, m200_11 # 201| r201_7(int) = Add : r201_6, r201_4 # 201| m201_8(int) = Store : &:r201_5, r201_7 # 202| r202_1(glval) = VariableAddress[#return] :