diff --git a/cpp/ql/lib/semmle/code/cpp/models/Models.qll b/cpp/ql/lib/semmle/code/cpp/models/Models.qll index 0b104e5e936..90a97777d8f 100644 --- a/cpp/ql/lib/semmle/code/cpp/models/Models.qll +++ b/cpp/ql/lib/semmle/code/cpp/models/Models.qll @@ -27,6 +27,11 @@ private import implementations.StdPair private import implementations.StdMap private import implementations.StdSet private import implementations.StdString +private import implementations.StdFunction +private import implementations.StdException +private import implementations.StdAllocator +private import implementations.StdAlgorithm +private import implementations.StdMath private import implementations.Swap private import implementations.GetDelim private import implementations.SmartPointer diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/Iterator.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/Iterator.qll index a016210de5a..3a93188e9ca 100644 --- a/cpp/ql/lib/semmle/code/cpp/models/implementations/Iterator.qll +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/Iterator.qll @@ -86,6 +86,41 @@ private class StdIterator extends Iterator, Class { override Type getValueType() { result = this.getTemplateArgument(1).(Type).getUnderlyingType() } } +private class StdReverseIterator extends Iterator, Class { + StdReverseIterator() { this.hasQualifiedName(["std", "bsl"], "reverse_iterator") } + + override Type getValueType() { result = this.getTemplateArgument(1).(Type).getUnderlyingType() } +} + +private class StdIstreamBufIterator extends Iterator, Class { + StdIstreamBufIterator() { this.hasQualifiedName(["std", "bsl"], "istreambuf_iterator") } + + override Type getValueType() { result = this.getTemplateArgument(1).(Type).getUnderlyingType() } +} + +private class StdIstreambufIteratorConstructor extends Constructor, SideEffectFunction, + AliasFunction +{ + StdIstreambufIteratorConstructor() { this.getDeclaringType() instanceof StdIstreamBufIterator } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and + buffer = false + } +} + /** * Gets the `FunctionInput` corresponding to an iterator parameter to * user-defined operator `op`, at `index`. @@ -579,23 +614,43 @@ private class IteratorAssignmentMemberOperatorModel extends IteratorAssignmentMe override predicate parameterEscapesOnlyViaReturn(int index) { index = -1 } } +private string beginName() { + result = ["begin", "cbegin", "rbegin", "crbegin", "before_begin", "cbefore_begin"] +} + /** * A `begin` member function, or a related function, that returns an iterator. */ -class BeginFunction extends MemberFunction { +class BeginFunction extends Function { BeginFunction() { - this.hasName(["begin", "cbegin", "rbegin", "crbegin", "before_begin", "cbefore_begin"]) and - this.getType().getUnspecifiedType() instanceof Iterator + this.getUnspecifiedType() instanceof Iterator and + ( + this.hasName(beginName()) and + this instanceof MemberFunction + or + this.hasGlobalOrStdOrBslName(beginName()) and + not this instanceof MemberFunction and + this.getNumberOfParameters() = 1 + ) } } +private string endName() { result = ["end", "cend", "rend", "crend"] } + /** * An `end` member function, or a related function, that returns an iterator. */ -class EndFunction extends MemberFunction { +class EndFunction extends Function { EndFunction() { - this.hasName(["end", "cend", "rend", "crend"]) and - this.getType().getUnspecifiedType() instanceof Iterator + this.getUnspecifiedType() instanceof Iterator and + ( + this.hasName(endName()) and + this instanceof MemberFunction + or + this.hasGlobalOrStdOrBslName(endName()) and + this instanceof MemberFunction and + this.getNumberOfParameters() = 1 + ) } } @@ -603,7 +658,7 @@ class EndFunction extends MemberFunction { * A `begin` or `end` member function, or a related member function, that * returns an iterator. */ -class BeginOrEndFunction extends MemberFunction { +class BeginOrEndFunction extends Function { BeginOrEndFunction() { this instanceof BeginFunction or this instanceof EndFunction diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/Printf.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/Printf.qll index 7474631397c..677b9245b6b 100644 --- a/cpp/ql/lib/semmle/code/cpp/models/implementations/Printf.qll +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/Printf.qll @@ -7,6 +7,7 @@ import semmle.code.cpp.models.interfaces.FormattingFunction import semmle.code.cpp.models.interfaces.Alias +import semmle.code.cpp.models.interfaces.SideEffect /** * The standard functions `printf`, `wprintf` and their glib variants. @@ -96,7 +97,7 @@ private class Sprintf extends FormattingFunction { /** * Implements `Snprintf`. */ -private class SnprintfImpl extends Snprintf { +private class SnprintfImpl extends Snprintf, AliasFunction, SideEffectFunction { SnprintfImpl() { this instanceof TopLevelFunction and ( @@ -143,6 +144,26 @@ private class SnprintfImpl extends Snprintf { } override int getSizeParameterIndex() { result = 1 } + + override predicate parameterNeverEscapes(int index) { + // We don't know how many parameters are passed to the function since it's varargs, but they also don't escape. + index = this.getFormatParameterIndex() + } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = this.getOutputParameterIndex(false) and buffer = true and mustWrite = false + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + // We don't know how many parameters are passed to the function since it's varargs, but they also have read side effects. + i = this.getFormatParameterIndex() and buffer = true + } } /** diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdAlgorithm.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdAlgorithm.qll new file mode 100644 index 00000000000..85b69fc8ac4 --- /dev/null +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdAlgorithm.qll @@ -0,0 +1,115 @@ +/** + * Provides models for C++ functions from the `algorithms` header. + */ + +import semmle.code.cpp.models.interfaces.Taint +import semmle.code.cpp.models.interfaces.DataFlow +import semmle.code.cpp.models.interfaces.Iterator +import semmle.code.cpp.models.interfaces.SideEffect +import semmle.code.cpp.models.interfaces.Alias + +private class StdPartialSort extends Function, SideEffectFunction, AliasFunction { + StdPartialSort() { this.hasGlobalOrStdName("partial_sort") } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = this.getAnIteratorParameterIndex() and buffer = true and mustWrite = false + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = this.getAnIteratorParameterIndex() and + buffer = true and + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and + buffer = false + } + + private int getAnIteratorParameterIndex() { + this.getParameter(result).getUnspecifiedType() instanceof Iterator + } + + override predicate parameterNeverEscapes(int index) { + index = this.getAnIteratorParameterIndex() + or + this.getParameter(index).getUnspecifiedType() instanceof ReferenceType + } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } +} + +private class StdSortHeap extends Function, SideEffectFunction, AliasFunction { + StdSortHeap() { this.hasGlobalOrStdName("sort_heap") } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = this.getAnIteratorParameterIndex() and buffer = true and mustWrite = false + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = this.getAnIteratorParameterIndex() and + buffer = true + } + + private int getAnIteratorParameterIndex() { + this.getParameter(result).getUnspecifiedType() instanceof Iterator + } + + override predicate parameterNeverEscapes(int index) { index = this.getAnIteratorParameterIndex() } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } +} + +private class StdGenerateN extends Function, SideEffectFunction, AliasFunction { + StdGenerateN() { this.hasGlobalOrStdName("generate_n") } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = this.getAnIteratorParameterIndex() and buffer = true and mustWrite = false + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and buffer = false + } + + private int getAnIteratorParameterIndex() { + this.getParameter(result).getUnspecifiedType() instanceof Iterator + } + + override predicate parameterNeverEscapes(int index) { index = this.getAnIteratorParameterIndex() } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } +} + +private class StdFindIfOrIfNot extends Function, SideEffectFunction, AliasFunction { + StdFindIfOrIfNot() { this.hasGlobalOrStdName(["find_if", "find_if_not"]) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = this.getAnIteratorParameterIndex() and buffer = true + or + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and buffer = false + } + + private int getAnIteratorParameterIndex() { + this.getParameter(result).getUnspecifiedType() instanceof Iterator + } + + override predicate parameterNeverEscapes(int index) { + this.getParameter(index).getUnspecifiedType() instanceof ReferenceType + } + + override predicate parameterEscapesOnlyViaReturn(int index) { + index = this.getAnIteratorParameterIndex() + } +} diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdAllocator.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdAllocator.qll new file mode 100644 index 00000000000..189d0ad862b --- /dev/null +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdAllocator.qll @@ -0,0 +1,256 @@ +/** + * Provides models for C++ `allocator` and `allocator_traits` classes. + */ + +import semmle.code.cpp.models.interfaces.SideEffect +import semmle.code.cpp.models.interfaces.Alias + +/** The `std::allocator` class. */ +class StdAllocator extends Class { + StdAllocator() { this.hasGlobalOrStdOrBslName("allocator") } +} + +/** The `std::allocator_traits` class. */ +class StdAllocatorTraits extends Class { + StdAllocatorTraits() { this.hasGlobalOrStdOrBslName("allocator_traits") } +} + +private class StdAllocatorConstructor extends Constructor, AliasFunction, SideEffectFunction { + StdAllocatorConstructor() { this.getDeclaringType() instanceof StdAllocator } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and + buffer = false and + mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and buffer = false + } +} + +private class StdAllocatorDestructor extends Destructor, AliasFunction, SideEffectFunction { + StdAllocatorDestructor() { this.getDeclaringType() instanceof StdAllocator } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and + buffer = false and + mustWrite = true + } +} + +private class StdAllocatorAddress extends MemberFunction, AliasFunction, SideEffectFunction { + StdAllocatorAddress() { this.getClassAndName("address") instanceof StdAllocator } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class StdAllocatorAllocate extends MemberFunction, AliasFunction, SideEffectFunction { + StdAllocatorAllocate() { this.getClassAndName("allocate") instanceof StdAllocator } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class StdAllocatorTraitsAllocate extends MemberFunction, AliasFunction, SideEffectFunction { + StdAllocatorTraitsAllocate() { + this.getClassAndName(["allocate", "allocate_at_least"]) instanceof StdAllocatorTraits + } + + override predicate parameterNeverEscapes(int index) { + this.getParameter(index).getUnspecifiedType() instanceof ReferenceType + } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and buffer = false + } +} + +private class StdAllocatorDeallocate extends MemberFunction, AliasFunction, SideEffectFunction { + StdAllocatorDeallocate() { this.getClassAndName("deallocate") instanceof StdAllocator } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = 0 and + buffer = false and + mustWrite = false + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = 0 and + buffer = false + } +} + +private class StdAllocatorTraitsDeallocate extends MemberFunction, AliasFunction, SideEffectFunction +{ + StdAllocatorTraitsDeallocate() { + this.getClassAndName("deallocate") instanceof StdAllocatorTraits + } + + override predicate parameterNeverEscapes(int index) { index = [0, 1] } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = 1 and + buffer = false and + mustWrite = false + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = [0, 1] and + buffer = false + } +} + +private class StdAllocatorMaxSize extends MemberFunction, AliasFunction, SideEffectFunction { + StdAllocatorMaxSize() { this.getClassAndName("max_size") instanceof StdAllocator } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class StdAllocatTraitsMaxSize extends MemberFunction, AliasFunction, SideEffectFunction { + StdAllocatTraitsMaxSize() { this.getClassAndName("max_size") instanceof StdAllocatorTraits } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class StdAllocatorConstruct extends MemberFunction, AliasFunction, SideEffectFunction { + StdAllocatorConstruct() { this.getClassAndName("construct") instanceof StdAllocator } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = 0 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and buffer = false + } +} + +class StdAllocatorTraitsConstruct extends MemberFunction, AliasFunction, SideEffectFunction { + StdAllocatorTraitsConstruct() { this.getClassAndName("construct") instanceof StdAllocatorTraits } + + override predicate parameterNeverEscapes(int index) { + index = 1 or this.getParameter(index).getUnspecifiedType() instanceof ReferenceType + } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = 1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and + buffer = false + } +} + +class StdAllocatorDestroy extends MemberFunction, AliasFunction, SideEffectFunction { + StdAllocatorDestroy() { this.getClassAndName("destroy") instanceof StdAllocator } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = 0 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = 0 and buffer = false + } +} + +class StdAllocatorTraitsDestroy extends MemberFunction, AliasFunction, SideEffectFunction { + StdAllocatorTraitsDestroy() { this.getClassAndName("destroy") instanceof StdAllocatorTraits } + + override predicate parameterNeverEscapes(int index) { index = [0, 1] } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = 1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = 0 and buffer = false + } +} diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdContainer.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdContainer.qll index bf9e05991b4..a6145fa724e 100644 --- a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdContainer.qll +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdContainer.qll @@ -4,6 +4,8 @@ import semmle.code.cpp.models.interfaces.FlowSource import semmle.code.cpp.models.interfaces.Iterator +import semmle.code.cpp.models.interfaces.SideEffect +import semmle.code.cpp.models.interfaces.Alias /** * A sequence container template class (for example, `std::vector`) from the @@ -58,7 +60,7 @@ private class Vector extends StdSequenceContainer { /** * The standard container functions `push_back` and `push_front`. */ -class StdSequenceContainerPush extends MemberFunction { +class StdSequenceContainerPush extends MemberFunction, SideEffectFunction, AliasFunction { StdSequenceContainerPush() { this.getClassAndName("push_back") instanceof Vector or this.getClassAndName(["push_back", "push_front"]) instanceof Deque or @@ -74,12 +76,115 @@ class StdSequenceContainerPush extends MemberFunction { this.getParameter(result).getUnspecifiedType().(ReferenceType).getBaseType() = this.getDeclaringType().getTemplateArgument(0).(Type).getUnspecifiedType() // i.e. the `T` of this `std::vector` } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and + buffer = false and + mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + // the `std::vector` specialization doesn't take a reference as a + // parameter. So we need to check that the parameter is actually a + // reference. + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and + buffer = false + } +} + +private class StdSequenceContainerPopFrontOrBack extends MemberFunction, SideEffectFunction, + AliasFunction +{ + StdSequenceContainerPopFrontOrBack() { + this.getClassAndName("pop_back") instanceof Vector or + this.getClassAndName("pop_front") instanceof ForwardList or + this.getClassAndName(["pop_front", "pop_back"]) instanceof Deque or + this.getClassAndName(["pop_front", "pop_back"]) instanceof List + } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and + buffer = false and + mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and + buffer = false + } +} + +private class StdSequenceContainerClear extends MemberFunction, SideEffectFunction, AliasFunction { + StdSequenceContainerClear() { + this.getClassAndName("clear") instanceof Vector or + this.getClassAndName("clear") instanceof Deque or + this.getClassAndName("clear") instanceof ForwardList or + this.getClassAndName("clear") instanceof List + } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and + buffer = false and + mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and + buffer = false + } +} + +private class StdVectorReserve extends MemberFunction, SideEffectFunction, AliasFunction { + StdVectorReserve() { this.getClassAndName("reserve") instanceof Vector } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and + buffer = false and + mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and + buffer = false + } } /** * The standard container functions `insert` and `insert_after`. */ -class StdSequenceContainerInsert extends MemberFunction { +class StdSequenceContainerInsert extends MemberFunction, SideEffectFunction, AliasFunction { StdSequenceContainerInsert() { this.getClassAndName("insert") instanceof Deque or this.getClassAndName("insert") instanceof List or @@ -100,17 +205,138 @@ class StdSequenceContainerInsert extends MemberFunction { * Gets the index of a parameter to this function that is an iterator. */ int getAnIteratorParameterIndex() { this.getParameter(result).getType() instanceof Iterator } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and + buffer = false and + mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and + buffer = false + } +} + +private class StdSequenceContainerFrontBack extends MemberFunction, SideEffectFunction, + AliasFunction +{ + StdSequenceContainerFrontBack() { + this.getClassAndName(["front", "back"]) instanceof Deque or + this.getClassAndName(["front", "back"]) instanceof List or + this.getClassAndName(["front", "back"]) instanceof Vector or + // forward_list does not have a 'back' member function + this.getClassAndName("front") instanceof ForwardList + } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + } } /** * The standard container functions `at` and `operator[]`. */ -class StdSequenceContainerAt extends MemberFunction { +class StdSequenceContainerAt extends MemberFunction, SideEffectFunction, AliasFunction { StdSequenceContainerAt() { this.getClassAndName(["at", "operator[]"]) instanceof Array or this.getClassAndName(["at", "operator[]"]) instanceof Deque or this.getClassAndName(["at", "operator[]"]) instanceof Vector } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + none() + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + } +} + +private class StdSequenceContainerMemberEquals extends MemberFunction, SideEffectFunction, + AliasFunction +{ + StdSequenceContainerMemberEquals() { + this.getClassAndName("operator==") instanceof Array or + this.getClassAndName("operator==") instanceof Deque or + this.getClassAndName("operator==") instanceof Vector + } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate parameterNeverEscapes(int index) { index = -1 or index = 0 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + none() + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + or + i = 0 and buffer = false + } +} + +private class StdSequenceContainerEquals extends Function, SideEffectFunction, AliasFunction { + StdSequenceContainerEquals() { + this.hasGlobalOrStdOrBslName("operator==") and + not this instanceof MemberFunction and + this.getNumberOfParameters() = 2 and + ( + this.getParameter(0).getUnspecifiedType().(ReferenceType).getBaseType() instanceof Vector and + this.getParameter(1).getUnspecifiedType().(ReferenceType).getBaseType() instanceof Vector + or + this.getParameter(0).getUnspecifiedType().(ReferenceType).getBaseType() instanceof List and + this.getParameter(1).getUnspecifiedType().(ReferenceType).getBaseType() instanceof List + or + this.getParameter(0).getUnspecifiedType().(ReferenceType).getBaseType() instanceof Deque and + this.getParameter(1).getUnspecifiedType().(ReferenceType).getBaseType() instanceof Deque + ) + } + + override predicate parameterNeverEscapes(int index) { index = 0 or index = 1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + none() + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = [0, 1] and buffer = false + } } /** @@ -142,6 +368,115 @@ class StdVectorEmplace extends StdSequenceEmplace { StdVectorEmplace() { this.getDeclaringType() instanceof Vector } } +private class StdSequenceSize extends MemberFunction, SideEffectFunction, AliasFunction { + StdSequenceSize() { + this.getClassAndName("size") instanceof Vector + or + this.getClassAndName("size") instanceof List + or + this.getClassAndName("size") instanceof Deque + } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + } +} + +private class StdSequenceDestructor extends Destructor, SideEffectFunction, AliasFunction { + StdSequenceDestructor() { + this.getDeclaringType() instanceof Vector + or + this.getDeclaringType() instanceof List + or + this.getDeclaringType() instanceof Deque + } + + private Destructor getElementDestructor() { + result.getDeclaringType() = this.getTemplateArgument(0) + } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { + this.getElementDestructor().(SideEffectFunction).hasOnlySpecificReadSideEffects() + or + not exists(this.getElementDestructor()) + } + + override predicate hasOnlySpecificWriteSideEffects() { + this.getElementDestructor().(SideEffectFunction).hasOnlySpecificWriteSideEffects() + or + not exists(this.getElementDestructor()) + } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + } +} + +private class StdSequenceConstructor extends Constructor, SideEffectFunction, AliasFunction { + StdSequenceConstructor() { + this.getDeclaringType() instanceof Vector + or + this.getDeclaringType() instanceof List + or + this.getDeclaringType() instanceof Deque + } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and + buffer = false + } +} + +private class InitializerList extends Class { + InitializerList() { this.hasQualifiedName(["std", "bsl"], "initializer_list") } + + Type getElementType() { result = this.getTemplateArgument(0) } +} + +private class InitializerListConstructor extends Constructor, SideEffectFunction, AliasFunction { + InitializerListConstructor() { this.getDeclaringType() instanceof InitializerList } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } +} + /** * The standard vector `emplace_back` function. */ diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdException.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdException.qll new file mode 100644 index 00000000000..e0d45f46814 --- /dev/null +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdException.qll @@ -0,0 +1,38 @@ +/** + * Provides models for the C++ `std::exception` class and subclasses. + */ + +import semmle.code.cpp.models.interfaces.Taint +import semmle.code.cpp.models.interfaces.Alias +import semmle.code.cpp.models.interfaces.SideEffect + +/** The `std::exception` class. */ +class StdException extends Class { + StdException() { this.hasGlobalOrStdOrBslName("exception") } +} + +/** The `std::bad_alloc` class. */ +class StdBadAllocException extends Class { + StdBadAllocException() { this.hasGlobalOrStdOrBslName("bad_alloc") } +} + +private class StdBadAllocExceptionConstructor extends Constructor, SideEffectFunction, AliasFunction +{ + StdBadAllocExceptionConstructor() { this.getDeclaringType() instanceof StdBadAllocException } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and buffer = false + } +} diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdFunction.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdFunction.qll new file mode 100644 index 00000000000..3b13c31b7c3 --- /dev/null +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdFunction.qll @@ -0,0 +1,53 @@ +/** + * Provides models for C++ `std::function` class. + */ + +import semmle.code.cpp.models.interfaces.SideEffect +import semmle.code.cpp.models.interfaces.Alias + +/** + * An instantiation of the `std::function` class template. + */ +class StdFunction extends ClassTemplateInstantiation { + StdFunction() { this.hasGlobalOrStdOrBslName("function") } +} + +private class StdFunctionConstructor extends Constructor, SideEffectFunction, AliasFunction { + StdFunctionConstructor() { this.getDeclaringType() instanceof StdFunction } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and buffer = false + } +} + +private class StdFunctionDestructor extends Destructor, SideEffectFunction, AliasFunction { + StdFunctionDestructor() { this.getDeclaringType() instanceof StdFunction } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + } +} diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdMap.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdMap.qll index ce3c596f308..5d2133b6f45 100644 --- a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdMap.qll +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdMap.qll @@ -5,6 +5,8 @@ import semmle.code.cpp.models.interfaces.Taint import semmle.code.cpp.models.interfaces.DataFlow import semmle.code.cpp.models.interfaces.Iterator +import semmle.code.cpp.models.interfaces.SideEffect +import semmle.code.cpp.models.interfaces.Alias /** * The `std::map` and `std::unordered_map` template classes. @@ -16,7 +18,9 @@ private class MapOrUnorderedMap extends Class { /** * Additional model for map constructors using iterator inputs. */ -private class StdMapConstructor extends Constructor, TaintFunction { +private class StdMapConstructor extends Constructor, TaintFunction, AliasFunction, + SideEffectFunction +{ StdMapConstructor() { this.getDeclaringType() instanceof MapOrUnorderedMap } /** @@ -35,6 +39,23 @@ private class StdMapConstructor extends Constructor, TaintFunction { output.isQualifierObject() ) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and + buffer = false + } } /** @@ -133,7 +154,7 @@ class StdMapAt extends MemberFunction { StdMapAt() { this.getClassAndName(["at", "operator[]"]) instanceof MapOrUnorderedMap } } -private class StdMapAtModels extends StdMapAt, TaintFunction { +private class StdMapAtModels extends StdMapAt, TaintFunction, AliasFunction, SideEffectFunction { override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { // flow from qualifier to referenced return value input.isQualifierObject() and @@ -144,6 +165,18 @@ private class StdMapAtModels extends StdMapAt, TaintFunction { output.isQualifierObject() } + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + } + override predicate isPartialWrite(FunctionOutput output) { output.isQualifierObject() } } @@ -187,3 +220,63 @@ private class StdMapEqualRange extends TaintFunction { output.isReturnValue() } } + +class StdMapDestructor extends Destructor, SideEffectFunction, AliasFunction { + StdMapDestructor() { this.getDeclaringType() instanceof MapOrUnorderedMap } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + } +} + +private class StdMapClear extends MemberFunction, SideEffectFunction, AliasFunction { + StdMapClear() { this.getClassAndName("clear") instanceof MapOrUnorderedMap } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and + buffer = false and + mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and + buffer = false + } +} + +class StdMapSize extends MemberFunction, SideEffectFunction, AliasFunction { + StdMapSize() { this.getClassAndName("size") instanceof MapOrUnorderedMap } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and + buffer = false + } +} diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdMath.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdMath.qll new file mode 100644 index 00000000000..fb443778754 --- /dev/null +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdMath.qll @@ -0,0 +1,98 @@ +/** + * Provides models for C++ functions from the `cmath` header. + */ + +private import semmle.code.cpp.models.interfaces.SideEffect +private import semmle.code.cpp.models.interfaces.Alias + +private class LdExp extends Function, SideEffectFunction { + LdExp() { this.hasGlobalOrStdOrBslName(["ldexp", "ldexpf", "ldexpl"]) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class Abs extends Function, SideEffectFunction { + Abs() { this.hasGlobalOrStdOrBslName(["abs", "fabs", "fabsf", "fabsl", "llabs", "imaxabs"]) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class Div extends Function, SideEffectFunction { + Div() { this.hasGlobalOrStdOrBslName(["div", "ldiv", "lldiv", "imaxdiv"]) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class FMod extends Function, SideEffectFunction { + FMod() { this.hasGlobalOrStdOrBslName(["fmod", "fmodf", "fmodl"]) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class Remainder extends Function, SideEffectFunction { + Remainder() { this.hasGlobalOrStdOrBslName(["remainder", "remainderf", "remainderl"]) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class Remquo extends Function, SideEffectFunction { + Remquo() { this.hasGlobalOrStdOrBslName(["remquo", "remquof", "remquol"]) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class Fma extends Function, SideEffectFunction { + Fma() { this.hasGlobalOrStdOrBslName(["fma", "fmaf", "fmal"]) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class Fmax extends Function, SideEffectFunction { + Fmax() { this.hasGlobalOrStdOrBslName(["fmax", "fmaxf", "fmaxl"]) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class Fmin extends Function, SideEffectFunction { + Fmin() { this.hasGlobalOrStdOrBslName(["fmin", "fminf", "fminl"]) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class Fdim extends Function, SideEffectFunction { + Fdim() { this.hasGlobalOrStdOrBslName(["fdim", "fdimf", "fdiml"]) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } +} + +private class Nan extends Function, SideEffectFunction, AliasFunction { + Nan() { this.hasGlobalOrStdOrBslName(["nan", "nanf", "nanl"]) } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate parameterNeverEscapes(int index) { index = 0 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } +} diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdPair.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdPair.qll index 28d05e5c306..54b6719e289 100644 --- a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdPair.qll +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdPair.qll @@ -3,6 +3,8 @@ */ import semmle.code.cpp.models.interfaces.Taint +import semmle.code.cpp.models.interfaces.Alias +import semmle.code.cpp.models.interfaces.SideEffect /** * An instantiation of `std::pair`. @@ -37,7 +39,9 @@ class StdPairCopyishConstructor extends Constructor, TaintFunction { /** * Additional model for `std::pair` constructors. */ -private class StdPairConstructor extends Constructor, TaintFunction { +private class StdPairConstructor extends Constructor, TaintFunction, AliasFunction, + SideEffectFunction +{ StdPairConstructor() { this.getDeclaringType() instanceof StdPair } /** @@ -59,4 +63,77 @@ private class StdPairConstructor extends Constructor, TaintFunction { output.isQualifierObject() ) } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + // All the constructor parameters are references with the exception of this one: + // ``` + // template + // pair(std::piecewise_construct_t, std::tuple first_args, std::tuple second_args); + // ``` + // So we need to check that the parameters are actually references + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and + buffer = false + } +} + +private class StdPairDestructor extends Destructor, AliasFunction, SideEffectFunction { + StdPairDestructor() { this.getDeclaringType() instanceof StdPair } + + private Type getFirstType() { result = this.getDeclaringType().getTemplateArgument(0) } + + private Type getSecondType() { result = this.getDeclaringType().getTemplateArgument(0) } + + private Type getAType() { result = [this.getFirstType(), this.getSecondType()] } + + /** + * Gets the destructor associated with the base type of this pair + */ + private Destructor getADestructor() { result.getDeclaringType() = this.getAType() } + + override predicate hasOnlySpecificReadSideEffects() { + this.getADestructor().(SideEffectFunction).hasOnlySpecificReadSideEffects() + or + // If there's no declared destructor for the base type then it won't have + // any strange read side effects. + not exists(this.getADestructor()) + } + + override predicate hasOnlySpecificWriteSideEffects() { + this.getADestructor().(SideEffectFunction).hasOnlySpecificWriteSideEffects() + or + // If there's no declared destructor for the base type then it won't have + // any strange write side effects. + not exists(this.getADestructor()) + } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate parameterNeverEscapes(int index) { + this.getADestructor().(AliasFunction).parameterNeverEscapes(index) + or + // If there's no declared destructor for the base type then it won't cause + // anything to escape. + not exists(this.getADestructor()) and + index = -1 + } } diff --git a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdString.qll b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdString.qll index fd28363297a..00dc8d26ad3 100644 --- a/cpp/ql/lib/semmle/code/cpp/models/implementations/StdString.qll +++ b/cpp/ql/lib/semmle/code/cpp/models/implementations/StdString.qll @@ -7,6 +7,8 @@ import semmle.code.cpp.models.interfaces.Taint import semmle.code.cpp.models.interfaces.Iterator import semmle.code.cpp.models.interfaces.DataFlow +import semmle.code.cpp.models.interfaces.SideEffect +import semmle.code.cpp.models.interfaces.Alias /** * The `std::basic_string` template class instantiations. @@ -78,7 +80,9 @@ abstract private class StdStringTaintFunction extends TaintFunction { * std::string b(a.begin(), a.end()); * ``` */ -private class StdStringConstructor extends Constructor, StdStringTaintFunction { +private class StdStringConstructor extends Constructor, StdStringTaintFunction, SideEffectFunction, + AliasFunction +{ StdStringConstructor() { this.getDeclaringType() instanceof StdBasicString } override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { @@ -94,6 +98,42 @@ private class StdStringConstructor extends Constructor, StdStringTaintFunction { output.isQualifierObject() ) } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + } +} + +private class StdStringDestructor extends Destructor, SideEffectFunction, AliasFunction { + StdStringDestructor() { this.getDeclaringType() instanceof StdBasicString } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + } } /** @@ -164,7 +204,7 @@ private class StdStringFrontBack extends StdStringTaintFunction { /** * The (non-member) `std::string` function `operator+`. */ -private class StdStringPlus extends StdStringTaintFunction { +private class StdStringPlus extends StdStringTaintFunction, SideEffectFunction, AliasFunction { StdStringPlus() { this.hasQualifiedName(["std", "bsl"], "operator+") and this.getUnspecifiedType() instanceof StdBasicString @@ -178,6 +218,22 @@ private class StdStringPlus extends StdStringTaintFunction { ) and output.isReturnValue() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + this.getParameter(i).getUnspecifiedType() instanceof ReferenceType and + buffer = false + or + this.getParameter(i).getUnspecifiedType() instanceof PointerType and + buffer = true + } + + override predicate parameterNeverEscapes(int index) { index = [0, 1] } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } } /** @@ -185,7 +241,7 @@ private class StdStringPlus extends StdStringTaintFunction { * All of these functions combine the existing string with a new * string (or character) from one of the arguments. */ -private class StdStringAppend extends StdStringTaintFunction { +private class StdStringAppend extends StdStringTaintFunction, SideEffectFunction, AliasFunction { StdStringAppend() { this.getClassAndName(["operator+=", "append", "replace"]) instanceof StdBasicString } @@ -210,6 +266,22 @@ private class StdStringAppend extends StdStringTaintFunction { } override predicate isPartialWrite(FunctionOutput output) { output.isQualifierObject() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and mustWrite = false and buffer = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = [-1, 0] and buffer = true + } + + override predicate parameterNeverEscapes(int index) { index = [-1, 0] } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } } /** @@ -301,7 +373,7 @@ private class StdStringSubstr extends StdStringTaintFunction { /** * The `std::string` functions `at` and `operator[]`. */ -private class StdStringAt extends StdStringTaintFunction { +private class StdStringAt extends StdStringTaintFunction, SideEffectFunction, AliasFunction { StdStringAt() { this.getClassAndName(["at", "operator[]"]) instanceof StdBasicString } override predicate hasTaintFlow(FunctionInput input, FunctionOutput output) { @@ -315,6 +387,22 @@ private class StdStringAt extends StdStringTaintFunction { } override predicate isPartialWrite(FunctionOutput output) { output.isQualifierObject() } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + none() + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + } } /** @@ -324,6 +412,54 @@ private class StdBasicIStream extends ClassTemplateInstantiation { StdBasicIStream() { this.hasQualifiedName(["std", "bsl"], "basic_istream") } } +private class StdBasicIfStream extends ClassTemplateInstantiation { + StdBasicIfStream() { this.hasQualifiedName(["std", "bsl"], "basic_ifstream") } +} + +class StdBasicIfStreamConstructor extends Constructor, SideEffectFunction, AliasFunction { + StdBasicIfStreamConstructor() { this.getDeclaringType() instanceof StdBasicIfStream } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + exists(Type t | t = this.getParameter(i).getUnspecifiedType() | + t instanceof PointerType and buffer = true + or + t instanceof ReferenceType and buffer = false + ) + } +} + +class StdBasicIfStreamDestructor extends Destructor, SideEffectFunction, AliasFunction { + StdBasicIfStreamDestructor() { this.getDeclaringType() instanceof StdBasicIfStream } + + override predicate parameterNeverEscapes(int index) { index = -1 } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + i = -1 and buffer = false and mustWrite = true + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = -1 and buffer = false + } +} + /** * The `std::istream` function `operator>>` (defined as a member function). */ @@ -542,6 +678,33 @@ private class StdBasicOStream extends ClassTemplateInstantiation { StdBasicOStream() { this.hasQualifiedName(["std", "bsl"], "basic_ostream") } } +private class StdStringLessThan extends Function, AliasFunction, SideEffectFunction { + StdStringLessThan() { + this.hasQualifiedName(["std", "bsl"], "operator<") and + this.getNumberOfParameters() = 2 and + this.getParameter(0).getUnspecifiedType().(ReferenceType).getBaseType() instanceof + StdBasicString and + this.getParameter(1).getUnspecifiedType().(ReferenceType).getBaseType() instanceof + StdBasicString + } + + override predicate parameterNeverEscapes(int index) { index = [0, 1] } + + override predicate parameterEscapesOnlyViaReturn(int index) { none() } + + override predicate hasOnlySpecificReadSideEffects() { any() } + + override predicate hasOnlySpecificWriteSideEffects() { any() } + + override predicate hasSpecificWriteSideEffect(ParameterIndex i, boolean buffer, boolean mustWrite) { + none() + } + + override predicate hasSpecificReadSideEffect(ParameterIndex i, boolean buffer) { + i = [0, 1] and buffer = false + } +} + /** * The `std::ostream` functions `operator<<` (defined as a member function), * `put` and `write`. diff --git a/cpp/ql/test/library-tests/ir/ir/aliased_ir.expected b/cpp/ql/test/library-tests/ir/ir/aliased_ir.expected index ea445b599fa..6a10e618ae3 100644 --- a/cpp/ql/test/library-tests/ir/ir/aliased_ir.expected +++ b/cpp/ql/test/library-tests/ir/ir/aliased_ir.expected @@ -15538,230 +15538,219 @@ ir.cpp: # 2215| m2215_8(ClassWithDestructor) = Chi : total:m2215_2, partial:m2215_7 # 2216| r2216_1(glval>) = VariableAddress[ys] : # 2216| m2216_2(vector) = Uninitialized[ys] : &:r2216_1 -# 2216| m2216_3(unknown) = Chi : total:m2215_6, partial:m2216_2 -# 2216| r2216_4(glval) = FunctionAddress[vector] : -# 2216| r2216_5(glval) = VariableAddress[#temp2216:45] : -# 2216| r2216_6(glval) = VariableAddress[x] : -# 2216| r2216_7(ClassWithDestructor) = Load[x] : &:r2216_6, m2215_8 -# 2216| m2216_8(ClassWithDestructor) = Store[#temp2216:45] : &:r2216_5, r2216_7 -# 2216| r2216_9(ClassWithDestructor) = Load[#temp2216:45] : &:r2216_5, m2216_8 -# 2216| v2216_10(void) = Call[vector] : func:r2216_4, this:r2216_1, 0:r2216_9 -# 2216| m2216_11(unknown) = ^CallSideEffect : ~m2216_3 -# 2216| m2216_12(unknown) = Chi : total:m2216_3, partial:m2216_11 -# 2216| m2216_13(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2216_1 -# 2216| m2216_14(unknown) = Chi : total:m2216_12, partial:m2216_13 -# 2216| r2216_15(glval) = CopyValue : r2216_5 -# 2216| r2216_16(glval) = FunctionAddress[~ClassWithDestructor] : -# 2216| v2216_17(void) = Call[~ClassWithDestructor] : func:r2216_16, this:r2216_15 -# 2216| m2216_18(unknown) = ^CallSideEffect : ~m2216_14 -# 2216| m2216_19(unknown) = Chi : total:m2216_14, partial:m2216_18 -# 2216| v2216_20(void) = ^IndirectReadSideEffect[-1] : &:r2216_15, m2216_8 -# 2216| m2216_21(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2216_15 -# 2216| m2216_22(ClassWithDestructor) = Chi : total:m2216_8, partial:m2216_21 -# 2216| r2216_23(glval &>) = VariableAddress[(__range)] : -# 2216| r2216_24(glval>) = VariableAddress[ys] : -# 2216| r2216_25(vector &) = CopyValue : r2216_24 -# 2216| m2216_26(vector &) = Store[(__range)] : &:r2216_23, r2216_25 -# 2216| r2216_27(glval>) = VariableAddress[(__begin)] : -# 2216| r2216_28(glval &>) = VariableAddress[(__range)] : -# 2216| r2216_29(vector &) = Load[(__range)] : &:r2216_28, m2216_26 -#-----| r0_1(glval>) = CopyValue : r2216_29 +# 2216| r2216_3(glval) = FunctionAddress[vector] : +# 2216| r2216_4(glval) = VariableAddress[#temp2216:45] : +# 2216| r2216_5(glval) = VariableAddress[x] : +# 2216| r2216_6(ClassWithDestructor) = Load[x] : &:r2216_5, m2215_8 +# 2216| m2216_7(ClassWithDestructor) = Store[#temp2216:45] : &:r2216_4, r2216_6 +# 2216| r2216_8(ClassWithDestructor) = Load[#temp2216:45] : &:r2216_4, m2216_7 +# 2216| v2216_9(void) = Call[vector] : func:r2216_3, this:r2216_1, 0:r2216_8 +# 2216| m2216_10(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2216_1 +# 2216| r2216_11(glval) = CopyValue : r2216_4 +# 2216| r2216_12(glval) = FunctionAddress[~ClassWithDestructor] : +# 2216| v2216_13(void) = Call[~ClassWithDestructor] : func:r2216_12, this:r2216_11 +# 2216| m2216_14(unknown) = ^CallSideEffect : ~m2215_6 +# 2216| m2216_15(unknown) = Chi : total:m2215_6, partial:m2216_14 +# 2216| v2216_16(void) = ^IndirectReadSideEffect[-1] : &:r2216_11, m2216_7 +# 2216| m2216_17(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2216_11 +# 2216| m2216_18(ClassWithDestructor) = Chi : total:m2216_7, partial:m2216_17 +# 2216| r2216_19(glval &>) = VariableAddress[(__range)] : +# 2216| r2216_20(glval>) = VariableAddress[ys] : +# 2216| r2216_21(vector &) = CopyValue : r2216_20 +# 2216| m2216_22(vector &) = Store[(__range)] : &:r2216_19, r2216_21 +# 2216| r2216_23(glval>) = VariableAddress[(__begin)] : +# 2216| r2216_24(glval &>) = VariableAddress[(__range)] : +# 2216| r2216_25(vector &) = Load[(__range)] : &:r2216_24, m2216_22 +#-----| r0_1(glval>) = CopyValue : r2216_25 #-----| r0_2(glval>) = Convert : r0_1 -# 2216| r2216_30(glval) = FunctionAddress[begin] : -# 2216| r2216_31(iterator) = Call[begin] : func:r2216_30, this:r0_2 -#-----| v0_3(void) = ^IndirectReadSideEffect[-1] : &:r0_2, ~m2216_19 -# 2216| m2216_32(iterator) = Store[(__begin)] : &:r2216_27, r2216_31 -# 2216| r2216_33(glval>) = VariableAddress[(__end)] : -# 2216| r2216_34(glval &>) = VariableAddress[(__range)] : -# 2216| r2216_35(vector &) = Load[(__range)] : &:r2216_34, m2216_26 -#-----| r0_4(glval>) = CopyValue : r2216_35 +# 2216| r2216_26(glval) = FunctionAddress[begin] : +# 2216| r2216_27(iterator) = Call[begin] : func:r2216_26, this:r0_2 +#-----| v0_3(void) = ^IndirectReadSideEffect[-1] : &:r0_2, m2216_10 +# 2216| m2216_28(iterator) = Store[(__begin)] : &:r2216_23, r2216_27 +# 2216| r2216_29(glval>) = VariableAddress[(__end)] : +# 2216| r2216_30(glval &>) = VariableAddress[(__range)] : +# 2216| r2216_31(vector &) = Load[(__range)] : &:r2216_30, m2216_22 +#-----| r0_4(glval>) = CopyValue : r2216_31 #-----| r0_5(glval>) = Convert : r0_4 -# 2216| r2216_36(glval) = FunctionAddress[end] : -# 2216| r2216_37(iterator) = Call[end] : func:r2216_36, this:r0_5 -#-----| v0_6(void) = ^IndirectReadSideEffect[-1] : &:r0_5, ~m2216_19 -# 2216| m2216_38(iterator) = Store[(__end)] : &:r2216_33, r2216_37 -# 2216| m2216_39(unknown) = Chi : total:m2216_19, partial:m2216_38 +# 2216| r2216_32(glval) = FunctionAddress[end] : +# 2216| r2216_33(iterator) = Call[end] : func:r2216_32, this:r0_5 +#-----| v0_6(void) = ^IndirectReadSideEffect[-1] : &:r0_5, m2216_10 +# 2216| m2216_34(iterator) = Store[(__end)] : &:r2216_29, r2216_33 +# 2216| m2216_35(unknown) = Chi : total:m2216_15, partial:m2216_34 #-----| Goto -> Block 8 # 2216| Block 8 -# 2216| m2216_40(iterator) = Phi : from 7:m2216_32, from 9:m2216_64 -# 2216| m2216_41(unknown) = Phi : from 7:~m2216_39, from 9:~m2216_69 -# 2216| r2216_42(glval>) = VariableAddress[(__begin)] : -#-----| r0_7(glval>) = Convert : r2216_42 -# 2216| r2216_43(glval) = FunctionAddress[operator!=] : +# 2216| m2216_36(iterator) = Phi : from 7:m2216_28, from 9:m2216_60 +# 2216| m2216_37(unknown) = Phi : from 7:~m2216_35, from 9:~m2216_65 +# 2216| r2216_38(glval>) = VariableAddress[(__begin)] : +#-----| r0_7(glval>) = Convert : r2216_38 +# 2216| r2216_39(glval) = FunctionAddress[operator!=] : #-----| r0_8(glval>) = VariableAddress[#temp0:0] : #-----| m0_9(iterator) = Uninitialized[#temp0:0] : &:r0_8 -#-----| m0_10(unknown) = Chi : total:m2216_41, partial:m0_9 -# 2216| r2216_44(glval) = FunctionAddress[iterator] : -# 2216| r2216_45(glval>) = VariableAddress[(__end)] : -#-----| r0_11(glval>) = Convert : r2216_45 +#-----| m0_10(unknown) = Chi : total:m2216_37, partial:m0_9 +# 2216| r2216_40(glval) = FunctionAddress[iterator] : +# 2216| r2216_41(glval>) = VariableAddress[(__end)] : +#-----| r0_11(glval>) = Convert : r2216_41 #-----| r0_12(iterator &) = CopyValue : r0_11 -# 2216| v2216_46(void) = Call[iterator] : func:r2216_44, this:r0_8, 0:r0_12 -# 2216| m2216_47(unknown) = ^CallSideEffect : ~m0_10 -# 2216| m2216_48(unknown) = Chi : total:m0_10, partial:m2216_47 -#-----| v0_13(void) = ^BufferReadSideEffect[0] : &:r0_12, ~m2216_48 -# 2216| m2216_49(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 -# 2216| m2216_50(unknown) = Chi : total:m2216_48, partial:m2216_49 -#-----| r0_14(iterator) = Load[#temp0:0] : &:r0_8, ~m2216_50 -# 2216| r2216_51(bool) = Call[operator!=] : func:r2216_43, this:r0_7, 0:r0_14 -#-----| v0_15(void) = ^IndirectReadSideEffect[-1] : &:r0_7, m2216_40 -# 2216| v2216_52(void) = ConditionalBranch : r2216_51 +# 2216| v2216_42(void) = Call[iterator] : func:r2216_40, this:r0_8, 0:r0_12 +# 2216| m2216_43(unknown) = ^CallSideEffect : ~m0_10 +# 2216| m2216_44(unknown) = Chi : total:m0_10, partial:m2216_43 +#-----| v0_13(void) = ^BufferReadSideEffect[0] : &:r0_12, ~m2216_44 +# 2216| m2216_45(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 +# 2216| m2216_46(unknown) = Chi : total:m2216_44, partial:m2216_45 +#-----| r0_14(iterator) = Load[#temp0:0] : &:r0_8, ~m2216_46 +# 2216| r2216_47(bool) = Call[operator!=] : func:r2216_39, this:r0_7, 0:r0_14 +#-----| v0_15(void) = ^IndirectReadSideEffect[-1] : &:r0_7, m2216_36 +# 2216| v2216_48(void) = ConditionalBranch : r2216_47 #-----| False -> Block 10 #-----| True -> Block 9 # 2216| Block 9 -# 2216| r2216_53(glval) = VariableAddress[y] : -# 2216| r2216_54(glval>) = VariableAddress[(__begin)] : -#-----| r0_16(glval>) = Convert : r2216_54 -# 2216| r2216_55(glval) = FunctionAddress[operator*] : -# 2216| r2216_56(ClassWithDestructor &) = Call[operator*] : func:r2216_55, this:r0_16 -#-----| v0_17(void) = ^IndirectReadSideEffect[-1] : &:r0_16, m2216_40 -# 2216| r2216_57(ClassWithDestructor) = Load[?] : &:r2216_56, ~m2216_50 -# 2216| m2216_58(ClassWithDestructor) = Store[y] : &:r2216_53, r2216_57 +# 2216| r2216_49(glval) = VariableAddress[y] : +# 2216| r2216_50(glval>) = VariableAddress[(__begin)] : +#-----| r0_16(glval>) = Convert : r2216_50 +# 2216| r2216_51(glval) = FunctionAddress[operator*] : +# 2216| r2216_52(ClassWithDestructor &) = Call[operator*] : func:r2216_51, this:r0_16 +#-----| v0_17(void) = ^IndirectReadSideEffect[-1] : &:r0_16, m2216_36 +# 2216| r2216_53(ClassWithDestructor) = Load[?] : &:r2216_52, ~m2216_46 +# 2216| m2216_54(ClassWithDestructor) = Store[y] : &:r2216_49, r2216_53 # 2217| r2217_1(glval) = VariableAddress[y] : # 2217| r2217_2(glval) = FunctionAddress[set_x] : # 2217| r2217_3(char) = Constant[97] : # 2217| v2217_4(void) = Call[set_x] : func:r2217_2, this:r2217_1, 0:r2217_3 -# 2217| m2217_5(unknown) = ^CallSideEffect : ~m2216_50 -# 2217| m2217_6(unknown) = Chi : total:m2216_50, partial:m2217_5 -# 2217| v2217_7(void) = ^IndirectReadSideEffect[-1] : &:r2217_1, m2216_58 +# 2217| m2217_5(unknown) = ^CallSideEffect : ~m2216_46 +# 2217| m2217_6(unknown) = Chi : total:m2216_46, partial:m2217_5 +# 2217| v2217_7(void) = ^IndirectReadSideEffect[-1] : &:r2217_1, m2216_54 # 2217| m2217_8(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2217_1 -# 2217| m2217_9(ClassWithDestructor) = Chi : total:m2216_58, partial:m2217_8 -# 2216| r2216_59(glval>) = VariableAddress[(__begin)] : -# 2216| r2216_60(glval) = FunctionAddress[operator++] : -# 2216| r2216_61(iterator &) = Call[operator++] : func:r2216_60, this:r2216_59 -# 2216| v2216_62(void) = ^IndirectReadSideEffect[-1] : &:r2216_59, m2216_40 -# 2216| m2216_63(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2216_59 -# 2216| m2216_64(iterator) = Chi : total:m2216_40, partial:m2216_63 -# 2216| r2216_65(glval) = VariableAddress[y] : -# 2216| r2216_66(glval) = FunctionAddress[~ClassWithDestructor] : -# 2216| v2216_67(void) = Call[~ClassWithDestructor] : func:r2216_66, this:r2216_65 -# 2216| m2216_68(unknown) = ^CallSideEffect : ~m2217_6 -# 2216| m2216_69(unknown) = Chi : total:m2217_6, partial:m2216_68 -# 2216| v2216_70(void) = ^IndirectReadSideEffect[-1] : &:r2216_65, m2217_9 -# 2216| m2216_71(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2216_65 -# 2216| m2216_72(ClassWithDestructor) = Chi : total:m2217_9, partial:m2216_71 -# 2216| r2216_73(glval>) = CopyValue : r2216_61 +# 2217| m2217_9(ClassWithDestructor) = Chi : total:m2216_54, partial:m2217_8 +# 2216| r2216_55(glval>) = VariableAddress[(__begin)] : +# 2216| r2216_56(glval) = FunctionAddress[operator++] : +# 2216| r2216_57(iterator &) = Call[operator++] : func:r2216_56, this:r2216_55 +# 2216| v2216_58(void) = ^IndirectReadSideEffect[-1] : &:r2216_55, m2216_36 +# 2216| m2216_59(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2216_55 +# 2216| m2216_60(iterator) = Chi : total:m2216_36, partial:m2216_59 +# 2216| r2216_61(glval) = VariableAddress[y] : +# 2216| r2216_62(glval) = FunctionAddress[~ClassWithDestructor] : +# 2216| v2216_63(void) = Call[~ClassWithDestructor] : func:r2216_62, this:r2216_61 +# 2216| m2216_64(unknown) = ^CallSideEffect : ~m2217_6 +# 2216| m2216_65(unknown) = Chi : total:m2217_6, partial:m2216_64 +# 2216| v2216_66(void) = ^IndirectReadSideEffect[-1] : &:r2216_61, m2217_9 +# 2216| m2216_67(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2216_61 +# 2216| m2216_68(ClassWithDestructor) = Chi : total:m2217_9, partial:m2216_67 +# 2216| r2216_69(glval>) = CopyValue : r2216_57 #-----| Goto (back edge) -> Block 8 # 2216| Block 10 -# 2216| r2216_74(glval>) = VariableAddress[ys] : -# 2216| r2216_75(glval) = FunctionAddress[~vector] : -# 2216| v2216_76(void) = Call[~vector] : func:r2216_75, this:r2216_74 -# 2216| m2216_77(unknown) = ^CallSideEffect : ~m2216_50 -# 2216| m2216_78(unknown) = Chi : total:m2216_50, partial:m2216_77 -# 2216| v2216_79(void) = ^IndirectReadSideEffect[-1] : &:r2216_74, ~m2216_78 -# 2216| m2216_80(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2216_74 -# 2216| m2216_81(unknown) = Chi : total:m2216_78, partial:m2216_80 +# 2216| r2216_70(glval>) = VariableAddress[ys] : +# 2216| r2216_71(glval) = FunctionAddress[~vector] : +# 2216| v2216_72(void) = Call[~vector] : func:r2216_71, this:r2216_70 +# 2216| v2216_73(void) = ^IndirectReadSideEffect[-1] : &:r2216_70, m2216_10 +# 2216| m2216_74(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2216_70 # 2219| r2219_1(glval>) = VariableAddress[ys] : # 2219| m2219_2(vector) = Uninitialized[ys] : &:r2219_1 -# 2219| m2219_3(unknown) = Chi : total:m2216_81, partial:m2219_2 -# 2219| r2219_4(glval) = FunctionAddress[vector] : -# 2219| r2219_5(glval) = VariableAddress[#temp2219:45] : -# 2219| r2219_6(glval) = VariableAddress[x] : -# 2219| r2219_7(ClassWithDestructor) = Load[x] : &:r2219_6, m2215_8 -# 2219| m2219_8(ClassWithDestructor) = Store[#temp2219:45] : &:r2219_5, r2219_7 -# 2219| r2219_9(ClassWithDestructor) = Load[#temp2219:45] : &:r2219_5, m2219_8 -# 2219| v2219_10(void) = Call[vector] : func:r2219_4, this:r2219_1, 0:r2219_9 -# 2219| m2219_11(unknown) = ^CallSideEffect : ~m2219_3 -# 2219| m2219_12(unknown) = Chi : total:m2219_3, partial:m2219_11 -# 2219| m2219_13(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2219_1 -# 2219| m2219_14(unknown) = Chi : total:m2219_12, partial:m2219_13 -# 2219| r2219_15(glval) = CopyValue : r2219_5 -# 2219| r2219_16(glval) = FunctionAddress[~ClassWithDestructor] : -# 2219| v2219_17(void) = Call[~ClassWithDestructor] : func:r2219_16, this:r2219_15 -# 2219| m2219_18(unknown) = ^CallSideEffect : ~m2219_14 -# 2219| m2219_19(unknown) = Chi : total:m2219_14, partial:m2219_18 -# 2219| v2219_20(void) = ^IndirectReadSideEffect[-1] : &:r2219_15, m2219_8 -# 2219| m2219_21(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2219_15 -# 2219| m2219_22(ClassWithDestructor) = Chi : total:m2219_8, partial:m2219_21 -# 2219| r2219_23(glval &>) = VariableAddress[(__range)] : -# 2219| r2219_24(glval>) = VariableAddress[ys] : -# 2219| r2219_25(vector &) = CopyValue : r2219_24 -# 2219| m2219_26(vector &) = Store[(__range)] : &:r2219_23, r2219_25 -# 2219| r2219_27(glval>) = VariableAddress[(__begin)] : -# 2219| r2219_28(glval &>) = VariableAddress[(__range)] : -# 2219| r2219_29(vector &) = Load[(__range)] : &:r2219_28, m2219_26 -#-----| r0_18(glval>) = CopyValue : r2219_29 +# 2219| r2219_3(glval) = FunctionAddress[vector] : +# 2219| r2219_4(glval) = VariableAddress[#temp2219:45] : +# 2219| r2219_5(glval) = VariableAddress[x] : +# 2219| r2219_6(ClassWithDestructor) = Load[x] : &:r2219_5, m2215_8 +# 2219| m2219_7(ClassWithDestructor) = Store[#temp2219:45] : &:r2219_4, r2219_6 +# 2219| r2219_8(ClassWithDestructor) = Load[#temp2219:45] : &:r2219_4, m2219_7 +# 2219| v2219_9(void) = Call[vector] : func:r2219_3, this:r2219_1, 0:r2219_8 +# 2219| m2219_10(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2219_1 +# 2219| r2219_11(glval) = CopyValue : r2219_4 +# 2219| r2219_12(glval) = FunctionAddress[~ClassWithDestructor] : +# 2219| v2219_13(void) = Call[~ClassWithDestructor] : func:r2219_12, this:r2219_11 +# 2219| m2219_14(unknown) = ^CallSideEffect : ~m2216_46 +# 2219| m2219_15(unknown) = Chi : total:m2216_46, partial:m2219_14 +# 2219| v2219_16(void) = ^IndirectReadSideEffect[-1] : &:r2219_11, m2219_7 +# 2219| m2219_17(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2219_11 +# 2219| m2219_18(ClassWithDestructor) = Chi : total:m2219_7, partial:m2219_17 +# 2219| r2219_19(glval &>) = VariableAddress[(__range)] : +# 2219| r2219_20(glval>) = VariableAddress[ys] : +# 2219| r2219_21(vector &) = CopyValue : r2219_20 +# 2219| m2219_22(vector &) = Store[(__range)] : &:r2219_19, r2219_21 +# 2219| r2219_23(glval>) = VariableAddress[(__begin)] : +# 2219| r2219_24(glval &>) = VariableAddress[(__range)] : +# 2219| r2219_25(vector &) = Load[(__range)] : &:r2219_24, m2219_22 +#-----| r0_18(glval>) = CopyValue : r2219_25 #-----| r0_19(glval>) = Convert : r0_18 -# 2219| r2219_30(glval) = FunctionAddress[begin] : -# 2219| r2219_31(iterator) = Call[begin] : func:r2219_30, this:r0_19 -#-----| v0_20(void) = ^IndirectReadSideEffect[-1] : &:r0_19, ~m2219_19 -# 2219| m2219_32(iterator) = Store[(__begin)] : &:r2219_27, r2219_31 -# 2219| r2219_33(glval>) = VariableAddress[(__end)] : -# 2219| r2219_34(glval &>) = VariableAddress[(__range)] : -# 2219| r2219_35(vector &) = Load[(__range)] : &:r2219_34, m2219_26 -#-----| r0_21(glval>) = CopyValue : r2219_35 +# 2219| r2219_26(glval) = FunctionAddress[begin] : +# 2219| r2219_27(iterator) = Call[begin] : func:r2219_26, this:r0_19 +#-----| v0_20(void) = ^IndirectReadSideEffect[-1] : &:r0_19, m2219_10 +# 2219| m2219_28(iterator) = Store[(__begin)] : &:r2219_23, r2219_27 +# 2219| r2219_29(glval>) = VariableAddress[(__end)] : +# 2219| r2219_30(glval &>) = VariableAddress[(__range)] : +# 2219| r2219_31(vector &) = Load[(__range)] : &:r2219_30, m2219_22 +#-----| r0_21(glval>) = CopyValue : r2219_31 #-----| r0_22(glval>) = Convert : r0_21 -# 2219| r2219_36(glval) = FunctionAddress[end] : -# 2219| r2219_37(iterator) = Call[end] : func:r2219_36, this:r0_22 -#-----| v0_23(void) = ^IndirectReadSideEffect[-1] : &:r0_22, ~m2219_19 -# 2219| m2219_38(iterator) = Store[(__end)] : &:r2219_33, r2219_37 -# 2219| m2219_39(unknown) = Chi : total:m2219_19, partial:m2219_38 +# 2219| r2219_32(glval) = FunctionAddress[end] : +# 2219| r2219_33(iterator) = Call[end] : func:r2219_32, this:r0_22 +#-----| v0_23(void) = ^IndirectReadSideEffect[-1] : &:r0_22, m2219_10 +# 2219| m2219_34(iterator) = Store[(__end)] : &:r2219_29, r2219_33 +# 2219| m2219_35(unknown) = Chi : total:m2219_15, partial:m2219_34 #-----| Goto -> Block 11 # 2219| Block 11 -# 2219| m2219_40(iterator) = Phi : from 10:m2219_32, from 12:m2219_58 -# 2219| m2219_41(unknown) = Phi : from 10:~m2219_39, from 12:~m2219_63 -# 2219| r2219_42(glval>) = VariableAddress[(__begin)] : -#-----| r0_24(glval>) = Convert : r2219_42 -# 2219| r2219_43(glval) = FunctionAddress[operator!=] : +# 2219| m2219_36(iterator) = Phi : from 10:m2219_28, from 12:m2219_54 +# 2219| m2219_37(unknown) = Phi : from 10:~m2219_35, from 12:~m2219_59 +# 2219| r2219_38(glval>) = VariableAddress[(__begin)] : +#-----| r0_24(glval>) = Convert : r2219_38 +# 2219| r2219_39(glval) = FunctionAddress[operator!=] : #-----| r0_25(glval>) = VariableAddress[#temp0:0] : #-----| m0_26(iterator) = Uninitialized[#temp0:0] : &:r0_25 -#-----| m0_27(unknown) = Chi : total:m2219_41, partial:m0_26 -# 2219| r2219_44(glval) = FunctionAddress[iterator] : -# 2219| r2219_45(glval>) = VariableAddress[(__end)] : -#-----| r0_28(glval>) = Convert : r2219_45 +#-----| m0_27(unknown) = Chi : total:m2219_37, partial:m0_26 +# 2219| r2219_40(glval) = FunctionAddress[iterator] : +# 2219| r2219_41(glval>) = VariableAddress[(__end)] : +#-----| r0_28(glval>) = Convert : r2219_41 #-----| r0_29(iterator &) = CopyValue : r0_28 -# 2219| v2219_46(void) = Call[iterator] : func:r2219_44, this:r0_25, 0:r0_29 -# 2219| m2219_47(unknown) = ^CallSideEffect : ~m0_27 -# 2219| m2219_48(unknown) = Chi : total:m0_27, partial:m2219_47 -#-----| v0_30(void) = ^BufferReadSideEffect[0] : &:r0_29, ~m2219_48 -# 2219| m2219_49(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_25 -# 2219| m2219_50(unknown) = Chi : total:m2219_48, partial:m2219_49 -#-----| r0_31(iterator) = Load[#temp0:0] : &:r0_25, ~m2219_50 -# 2219| r2219_51(bool) = Call[operator!=] : func:r2219_43, this:r0_24, 0:r0_31 -#-----| v0_32(void) = ^IndirectReadSideEffect[-1] : &:r0_24, m2219_40 -# 2219| v2219_52(void) = ConditionalBranch : r2219_51 +# 2219| v2219_42(void) = Call[iterator] : func:r2219_40, this:r0_25, 0:r0_29 +# 2219| m2219_43(unknown) = ^CallSideEffect : ~m0_27 +# 2219| m2219_44(unknown) = Chi : total:m0_27, partial:m2219_43 +#-----| v0_30(void) = ^BufferReadSideEffect[0] : &:r0_29, ~m2219_44 +# 2219| m2219_45(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_25 +# 2219| m2219_46(unknown) = Chi : total:m2219_44, partial:m2219_45 +#-----| r0_31(iterator) = Load[#temp0:0] : &:r0_25, ~m2219_46 +# 2219| r2219_47(bool) = Call[operator!=] : func:r2219_39, this:r0_24, 0:r0_31 +#-----| v0_32(void) = ^IndirectReadSideEffect[-1] : &:r0_24, m2219_36 +# 2219| v2219_48(void) = ConditionalBranch : r2219_47 #-----| False -> Block 15 #-----| True -> Block 13 # 2219| Block 12 -# 2219| r2219_53(glval>) = VariableAddress[(__begin)] : -# 2219| r2219_54(glval) = FunctionAddress[operator++] : -# 2219| r2219_55(iterator &) = Call[operator++] : func:r2219_54, this:r2219_53 -# 2219| v2219_56(void) = ^IndirectReadSideEffect[-1] : &:r2219_53, m2219_40 -# 2219| m2219_57(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2219_53 -# 2219| m2219_58(iterator) = Chi : total:m2219_40, partial:m2219_57 -# 2219| r2219_59(glval) = VariableAddress[y] : -# 2219| r2219_60(glval) = FunctionAddress[~ClassWithDestructor] : -# 2219| v2219_61(void) = Call[~ClassWithDestructor] : func:r2219_60, this:r2219_59 -# 2219| m2219_62(unknown) = ^CallSideEffect : ~m2221_5 -# 2219| m2219_63(unknown) = Chi : total:m2221_5, partial:m2219_62 -# 2219| v2219_64(void) = ^IndirectReadSideEffect[-1] : &:r2219_59, m2221_8 -# 2219| m2219_65(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2219_59 -# 2219| m2219_66(ClassWithDestructor) = Chi : total:m2221_8, partial:m2219_65 -# 2219| r2219_67(glval>) = CopyValue : r2219_55 +# 2219| r2219_49(glval>) = VariableAddress[(__begin)] : +# 2219| r2219_50(glval) = FunctionAddress[operator++] : +# 2219| r2219_51(iterator &) = Call[operator++] : func:r2219_50, this:r2219_49 +# 2219| v2219_52(void) = ^IndirectReadSideEffect[-1] : &:r2219_49, m2219_36 +# 2219| m2219_53(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2219_49 +# 2219| m2219_54(iterator) = Chi : total:m2219_36, partial:m2219_53 +# 2219| r2219_55(glval) = VariableAddress[y] : +# 2219| r2219_56(glval) = FunctionAddress[~ClassWithDestructor] : +# 2219| v2219_57(void) = Call[~ClassWithDestructor] : func:r2219_56, this:r2219_55 +# 2219| m2219_58(unknown) = ^CallSideEffect : ~m2221_5 +# 2219| m2219_59(unknown) = Chi : total:m2221_5, partial:m2219_58 +# 2219| v2219_60(void) = ^IndirectReadSideEffect[-1] : &:r2219_55, m2221_8 +# 2219| m2219_61(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2219_55 +# 2219| m2219_62(ClassWithDestructor) = Chi : total:m2221_8, partial:m2219_61 +# 2219| r2219_63(glval>) = CopyValue : r2219_51 #-----| Goto (back edge) -> Block 11 # 2219| Block 13 -# 2219| r2219_68(glval) = VariableAddress[y] : -# 2219| r2219_69(glval>) = VariableAddress[(__begin)] : -#-----| r0_33(glval>) = Convert : r2219_69 -# 2219| r2219_70(glval) = FunctionAddress[operator*] : -# 2219| r2219_71(ClassWithDestructor &) = Call[operator*] : func:r2219_70, this:r0_33 -#-----| v0_34(void) = ^IndirectReadSideEffect[-1] : &:r0_33, m2219_40 -# 2219| r2219_72(ClassWithDestructor) = Load[?] : &:r2219_71, ~m2219_50 -# 2219| m2219_73(ClassWithDestructor) = Store[y] : &:r2219_68, r2219_72 +# 2219| r2219_64(glval) = VariableAddress[y] : +# 2219| r2219_65(glval>) = VariableAddress[(__begin)] : +#-----| r0_33(glval>) = Convert : r2219_65 +# 2219| r2219_66(glval) = FunctionAddress[operator*] : +# 2219| r2219_67(ClassWithDestructor &) = Call[operator*] : func:r2219_66, this:r0_33 +#-----| v0_34(void) = ^IndirectReadSideEffect[-1] : &:r0_33, m2219_36 +# 2219| r2219_68(ClassWithDestructor) = Load[?] : &:r2219_67, ~m2219_46 +# 2219| m2219_69(ClassWithDestructor) = Store[y] : &:r2219_64, r2219_68 # 2220| r2220_1(glval) = VariableAddress[y] : # 2220| r2220_2(glval) = FunctionAddress[set_x] : # 2220| r2220_3(char) = Constant[97] : # 2220| v2220_4(void) = Call[set_x] : func:r2220_2, this:r2220_1, 0:r2220_3 -# 2220| m2220_5(unknown) = ^CallSideEffect : ~m2219_50 -# 2220| m2220_6(unknown) = Chi : total:m2219_50, partial:m2220_5 -# 2220| v2220_7(void) = ^IndirectReadSideEffect[-1] : &:r2220_1, m2219_73 +# 2220| m2220_5(unknown) = ^CallSideEffect : ~m2219_46 +# 2220| m2220_6(unknown) = Chi : total:m2219_46, partial:m2220_5 +# 2220| v2220_7(void) = ^IndirectReadSideEffect[-1] : &:r2220_1, m2219_69 # 2220| m2220_8(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2220_1 -# 2220| m2220_9(ClassWithDestructor) = Chi : total:m2219_73, partial:m2220_8 +# 2220| m2220_9(ClassWithDestructor) = Chi : total:m2219_69, partial:m2220_8 # 2221| r2221_1(glval) = VariableAddress[y] : # 2221| r2221_2(glval) = FunctionAddress[get_x] : # 2221| r2221_3(char) = Call[get_x] : func:r2221_2, this:r2221_1 @@ -15779,123 +15768,113 @@ ir.cpp: # 2222| Block 14 # 2222| v2222_1(void) = NoOp : -# 2219| r2219_74(glval) = VariableAddress[y] : -# 2219| r2219_75(glval) = FunctionAddress[~ClassWithDestructor] : -# 2219| v2219_76(void) = Call[~ClassWithDestructor] : func:r2219_75, this:r2219_74 -# 2219| m2219_77(unknown) = ^CallSideEffect : ~m2221_5 -# 2219| m2219_78(unknown) = Chi : total:m2221_5, partial:m2219_77 -# 2219| v2219_79(void) = ^IndirectReadSideEffect[-1] : &:r2219_74, m2221_8 -# 2219| m2219_80(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2219_74 -# 2219| m2219_81(ClassWithDestructor) = Chi : total:m2221_8, partial:m2219_80 -# 2219| r2219_82(glval>) = VariableAddress[ys] : -# 2219| r2219_83(glval) = FunctionAddress[~vector] : -# 2219| v2219_84(void) = Call[~vector] : func:r2219_83, this:r2219_82 -# 2219| m2219_85(unknown) = ^CallSideEffect : ~m2219_78 -# 2219| m2219_86(unknown) = Chi : total:m2219_78, partial:m2219_85 -# 2219| v2219_87(void) = ^IndirectReadSideEffect[-1] : &:r2219_82, ~m2219_86 -# 2219| m2219_88(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2219_82 -# 2219| m2219_89(unknown) = Chi : total:m2219_86, partial:m2219_88 +# 2219| r2219_70(glval) = VariableAddress[y] : +# 2219| r2219_71(glval) = FunctionAddress[~ClassWithDestructor] : +# 2219| v2219_72(void) = Call[~ClassWithDestructor] : func:r2219_71, this:r2219_70 +# 2219| m2219_73(unknown) = ^CallSideEffect : ~m2221_5 +# 2219| m2219_74(unknown) = Chi : total:m2221_5, partial:m2219_73 +# 2219| v2219_75(void) = ^IndirectReadSideEffect[-1] : &:r2219_70, m2221_8 +# 2219| m2219_76(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2219_70 +# 2219| m2219_77(ClassWithDestructor) = Chi : total:m2221_8, partial:m2219_76 +# 2219| r2219_78(glval>) = VariableAddress[ys] : +# 2219| r2219_79(glval) = FunctionAddress[~vector] : +# 2219| v2219_80(void) = Call[~vector] : func:r2219_79, this:r2219_78 +# 2219| v2219_81(void) = ^IndirectReadSideEffect[-1] : &:r2219_78, m2219_10 +# 2219| m2219_82(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2219_78 # 2234| r2234_1(glval) = VariableAddress[x] : # 2234| r2234_2(glval) = FunctionAddress[~ClassWithDestructor] : # 2234| v2234_3(void) = Call[~ClassWithDestructor] : func:r2234_2, this:r2234_1 -# 2234| m2234_4(unknown) = ^CallSideEffect : ~m2219_89 -# 2234| m2234_5(unknown) = Chi : total:m2219_89, partial:m2234_4 +# 2234| m2234_4(unknown) = ^CallSideEffect : ~m2219_74 +# 2234| m2234_5(unknown) = Chi : total:m2219_74, partial:m2234_4 # 2234| v2234_6(void) = ^IndirectReadSideEffect[-1] : &:r2234_1, m2215_8 # 2234| m2234_7(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2234_1 # 2234| m2234_8(ClassWithDestructor) = Chi : total:m2215_8, partial:m2234_7 #-----| Goto -> Block 1 # 2219| Block 15 -# 2219| r2219_90(glval>) = VariableAddress[ys] : -# 2219| r2219_91(glval) = FunctionAddress[~vector] : -# 2219| v2219_92(void) = Call[~vector] : func:r2219_91, this:r2219_90 -# 2219| m2219_93(unknown) = ^CallSideEffect : ~m2219_50 -# 2219| m2219_94(unknown) = Chi : total:m2219_50, partial:m2219_93 -# 2219| v2219_95(void) = ^IndirectReadSideEffect[-1] : &:r2219_90, ~m2219_94 -# 2219| m2219_96(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2219_90 -# 2219| m2219_97(unknown) = Chi : total:m2219_94, partial:m2219_96 -# 2225| r2225_1(glval>) = VariableAddress[ys] : -# 2225| m2225_2(vector) = Uninitialized[ys] : &:r2225_1 -# 2225| m2225_3(unknown) = Chi : total:m2219_97, partial:m2225_2 -# 2225| r2225_4(glval) = FunctionAddress[vector] : -# 2225| r2225_5(int) = Constant[1] : -# 2225| v2225_6(void) = Call[vector] : func:r2225_4, this:r2225_1, 0:r2225_5 -# 2225| m2225_7(unknown) = ^CallSideEffect : ~m2225_3 -# 2225| m2225_8(unknown) = Chi : total:m2225_3, partial:m2225_7 -# 2225| m2225_9(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2225_1 -# 2225| m2225_10(unknown) = Chi : total:m2225_8, partial:m2225_9 -# 2225| r2225_11(glval &>) = VariableAddress[(__range)] : -# 2225| r2225_12(glval>) = VariableAddress[ys] : -# 2225| r2225_13(vector &) = CopyValue : r2225_12 -# 2225| m2225_14(vector &) = Store[(__range)] : &:r2225_11, r2225_13 -# 2225| r2225_15(glval>) = VariableAddress[(__begin)] : -# 2225| r2225_16(glval &>) = VariableAddress[(__range)] : -# 2225| r2225_17(vector &) = Load[(__range)] : &:r2225_16, m2225_14 -#-----| r0_35(glval>) = CopyValue : r2225_17 -#-----| r0_36(glval>) = Convert : r0_35 -# 2225| r2225_18(glval) = FunctionAddress[begin] : -# 2225| r2225_19(iterator) = Call[begin] : func:r2225_18, this:r0_36 -#-----| v0_37(void) = ^IndirectReadSideEffect[-1] : &:r0_36, ~m2225_10 -# 2225| m2225_20(iterator) = Store[(__begin)] : &:r2225_15, r2225_19 -# 2225| r2225_21(glval>) = VariableAddress[(__end)] : -# 2225| r2225_22(glval &>) = VariableAddress[(__range)] : -# 2225| r2225_23(vector &) = Load[(__range)] : &:r2225_22, m2225_14 -#-----| r0_38(glval>) = CopyValue : r2225_23 -#-----| r0_39(glval>) = Convert : r0_38 -# 2225| r2225_24(glval) = FunctionAddress[end] : -# 2225| r2225_25(iterator) = Call[end] : func:r2225_24, this:r0_39 -#-----| v0_40(void) = ^IndirectReadSideEffect[-1] : &:r0_39, ~m2225_10 -# 2225| m2225_26(iterator) = Store[(__end)] : &:r2225_21, r2225_25 -# 2225| m2225_27(unknown) = Chi : total:m2225_10, partial:m2225_26 +# 2219| r2219_83(glval>) = VariableAddress[ys] : +# 2219| r2219_84(glval) = FunctionAddress[~vector] : +# 2219| v2219_85(void) = Call[~vector] : func:r2219_84, this:r2219_83 +# 2219| v2219_86(void) = ^IndirectReadSideEffect[-1] : &:r2219_83, m2219_10 +# 2219| m2219_87(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2219_83 +# 2225| r2225_1(glval>) = VariableAddress[ys] : +# 2225| m2225_2(vector) = Uninitialized[ys] : &:r2225_1 +# 2225| r2225_3(glval) = FunctionAddress[vector] : +# 2225| r2225_4(int) = Constant[1] : +# 2225| v2225_5(void) = Call[vector] : func:r2225_3, this:r2225_1, 0:r2225_4 +# 2225| m2225_6(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2225_1 +# 2225| r2225_7(glval &>) = VariableAddress[(__range)] : +# 2225| r2225_8(glval>) = VariableAddress[ys] : +# 2225| r2225_9(vector &) = CopyValue : r2225_8 +# 2225| m2225_10(vector &) = Store[(__range)] : &:r2225_7, r2225_9 +# 2225| r2225_11(glval>) = VariableAddress[(__begin)] : +# 2225| r2225_12(glval &>) = VariableAddress[(__range)] : +# 2225| r2225_13(vector &) = Load[(__range)] : &:r2225_12, m2225_10 +#-----| r0_35(glval>) = CopyValue : r2225_13 +#-----| r0_36(glval>) = Convert : r0_35 +# 2225| r2225_14(glval) = FunctionAddress[begin] : +# 2225| r2225_15(iterator) = Call[begin] : func:r2225_14, this:r0_36 +#-----| v0_37(void) = ^IndirectReadSideEffect[-1] : &:r0_36, m2225_6 +# 2225| m2225_16(iterator) = Store[(__begin)] : &:r2225_11, r2225_15 +# 2225| r2225_17(glval>) = VariableAddress[(__end)] : +# 2225| r2225_18(glval &>) = VariableAddress[(__range)] : +# 2225| r2225_19(vector &) = Load[(__range)] : &:r2225_18, m2225_10 +#-----| r0_38(glval>) = CopyValue : r2225_19 +#-----| r0_39(glval>) = Convert : r0_38 +# 2225| r2225_20(glval) = FunctionAddress[end] : +# 2225| r2225_21(iterator) = Call[end] : func:r2225_20, this:r0_39 +#-----| v0_40(void) = ^IndirectReadSideEffect[-1] : &:r0_39, m2225_6 +# 2225| m2225_22(iterator) = Store[(__end)] : &:r2225_17, r2225_21 +# 2225| m2225_23(unknown) = Chi : total:m2219_46, partial:m2225_22 #-----| Goto -> Block 16 # 2225| Block 16 -# 2225| m2225_28(iterator) = Phi : from 15:m2225_20, from 17:m2225_46 -# 2225| m2225_29(unknown) = Phi : from 15:~m2225_27, from 17:~m2225_38 -# 2225| r2225_30(glval>) = VariableAddress[(__begin)] : -#-----| r0_41(glval>) = Convert : r2225_30 -# 2225| r2225_31(glval) = FunctionAddress[operator!=] : +# 2225| m2225_24(iterator) = Phi : from 15:m2225_16, from 17:m2225_42 +# 2225| m2225_25(unknown) = Phi : from 15:~m2225_23, from 17:~m2225_34 +# 2225| r2225_26(glval>) = VariableAddress[(__begin)] : +#-----| r0_41(glval>) = Convert : r2225_26 +# 2225| r2225_27(glval) = FunctionAddress[operator!=] : #-----| r0_42(glval>) = VariableAddress[#temp0:0] : #-----| m0_43(iterator) = Uninitialized[#temp0:0] : &:r0_42 -#-----| m0_44(unknown) = Chi : total:m2225_29, partial:m0_43 -# 2225| r2225_32(glval) = FunctionAddress[iterator] : -# 2225| r2225_33(glval>) = VariableAddress[(__end)] : -#-----| r0_45(glval>) = Convert : r2225_33 +#-----| m0_44(unknown) = Chi : total:m2225_25, partial:m0_43 +# 2225| r2225_28(glval) = FunctionAddress[iterator] : +# 2225| r2225_29(glval>) = VariableAddress[(__end)] : +#-----| r0_45(glval>) = Convert : r2225_29 #-----| r0_46(iterator &) = CopyValue : r0_45 -# 2225| v2225_34(void) = Call[iterator] : func:r2225_32, this:r0_42, 0:r0_46 -# 2225| m2225_35(unknown) = ^CallSideEffect : ~m0_44 -# 2225| m2225_36(unknown) = Chi : total:m0_44, partial:m2225_35 -#-----| v0_47(void) = ^BufferReadSideEffect[0] : &:r0_46, ~m2225_36 -# 2225| m2225_37(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_42 -# 2225| m2225_38(unknown) = Chi : total:m2225_36, partial:m2225_37 -#-----| r0_48(iterator) = Load[#temp0:0] : &:r0_42, ~m2225_38 -# 2225| r2225_39(bool) = Call[operator!=] : func:r2225_31, this:r0_41, 0:r0_48 -#-----| v0_49(void) = ^IndirectReadSideEffect[-1] : &:r0_41, m2225_28 -# 2225| v2225_40(void) = ConditionalBranch : r2225_39 +# 2225| v2225_30(void) = Call[iterator] : func:r2225_28, this:r0_42, 0:r0_46 +# 2225| m2225_31(unknown) = ^CallSideEffect : ~m0_44 +# 2225| m2225_32(unknown) = Chi : total:m0_44, partial:m2225_31 +#-----| v0_47(void) = ^BufferReadSideEffect[0] : &:r0_46, ~m2225_32 +# 2225| m2225_33(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_42 +# 2225| m2225_34(unknown) = Chi : total:m2225_32, partial:m2225_33 +#-----| r0_48(iterator) = Load[#temp0:0] : &:r0_42, ~m2225_34 +# 2225| r2225_35(bool) = Call[operator!=] : func:r2225_27, this:r0_41, 0:r0_48 +#-----| v0_49(void) = ^IndirectReadSideEffect[-1] : &:r0_41, m2225_24 +# 2225| v2225_36(void) = ConditionalBranch : r2225_35 #-----| False -> Block 20 #-----| True -> Block 18 # 2225| Block 17 -# 2225| r2225_41(glval>) = VariableAddress[(__begin)] : -# 2225| r2225_42(glval) = FunctionAddress[operator++] : -# 2225| r2225_43(iterator &) = Call[operator++] : func:r2225_42, this:r2225_41 -# 2225| v2225_44(void) = ^IndirectReadSideEffect[-1] : &:r2225_41, m2225_28 -# 2225| m2225_45(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2225_41 -# 2225| m2225_46(iterator) = Chi : total:m2225_28, partial:m2225_45 -# 2225| r2225_47(glval>) = CopyValue : r2225_43 +# 2225| r2225_37(glval>) = VariableAddress[(__begin)] : +# 2225| r2225_38(glval) = FunctionAddress[operator++] : +# 2225| r2225_39(iterator &) = Call[operator++] : func:r2225_38, this:r2225_37 +# 2225| v2225_40(void) = ^IndirectReadSideEffect[-1] : &:r2225_37, m2225_24 +# 2225| m2225_41(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2225_37 +# 2225| m2225_42(iterator) = Chi : total:m2225_24, partial:m2225_41 +# 2225| r2225_43(glval>) = CopyValue : r2225_39 #-----| Goto (back edge) -> Block 16 # 2225| Block 18 -# 2225| r2225_48(glval) = VariableAddress[y] : -# 2225| r2225_49(glval>) = VariableAddress[(__begin)] : -#-----| r0_50(glval>) = Convert : r2225_49 -# 2225| r2225_50(glval) = FunctionAddress[operator*] : -# 2225| r2225_51(int &) = Call[operator*] : func:r2225_50, this:r0_50 -#-----| v0_51(void) = ^IndirectReadSideEffect[-1] : &:r0_50, m2225_28 -# 2225| r2225_52(int) = Load[?] : &:r2225_51, ~m2225_38 -# 2225| m2225_53(int) = Store[y] : &:r2225_48, r2225_52 +# 2225| r2225_44(glval) = VariableAddress[y] : +# 2225| r2225_45(glval>) = VariableAddress[(__begin)] : +#-----| r0_50(glval>) = Convert : r2225_45 +# 2225| r2225_46(glval) = FunctionAddress[operator*] : +# 2225| r2225_47(int &) = Call[operator*] : func:r2225_46, this:r0_50 +#-----| v0_51(void) = ^IndirectReadSideEffect[-1] : &:r0_50, m2225_24 +# 2225| r2225_48(int) = Load[?] : &:r2225_47, ~m2225_34 +# 2225| m2225_49(int) = Store[y] : &:r2225_44, r2225_48 # 2226| r2226_1(glval) = VariableAddress[y] : -# 2226| r2226_2(int) = Load[y] : &:r2226_1, m2225_53 +# 2226| r2226_2(int) = Load[y] : &:r2226_1, m2225_49 # 2226| r2226_3(int) = Constant[1] : # 2226| r2226_4(bool) = CompareEQ : r2226_2, r2226_3 # 2226| v2226_5(void) = ConditionalBranch : r2226_4 @@ -15904,121 +15883,111 @@ ir.cpp: # 2227| Block 19 # 2227| v2227_1(void) = NoOp : -# 2225| r2225_54(glval>) = VariableAddress[ys] : -# 2225| r2225_55(glval) = FunctionAddress[~vector] : -# 2225| v2225_56(void) = Call[~vector] : func:r2225_55, this:r2225_54 -# 2225| m2225_57(unknown) = ^CallSideEffect : ~m2225_38 -# 2225| m2225_58(unknown) = Chi : total:m2225_38, partial:m2225_57 -# 2225| v2225_59(void) = ^IndirectReadSideEffect[-1] : &:r2225_54, ~m2225_58 -# 2225| m2225_60(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2225_54 -# 2225| m2225_61(unknown) = Chi : total:m2225_58, partial:m2225_60 +# 2225| r2225_50(glval>) = VariableAddress[ys] : +# 2225| r2225_51(glval) = FunctionAddress[~vector] : +# 2225| v2225_52(void) = Call[~vector] : func:r2225_51, this:r2225_50 +# 2225| v2225_53(void) = ^IndirectReadSideEffect[-1] : &:r2225_50, m2225_6 +# 2225| m2225_54(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2225_50 # 2234| r2234_9(glval) = VariableAddress[x] : # 2234| r2234_10(glval) = FunctionAddress[~ClassWithDestructor] : # 2234| v2234_11(void) = Call[~ClassWithDestructor] : func:r2234_10, this:r2234_9 -# 2234| m2234_12(unknown) = ^CallSideEffect : ~m2225_61 -# 2234| m2234_13(unknown) = Chi : total:m2225_61, partial:m2234_12 +# 2234| m2234_12(unknown) = ^CallSideEffect : ~m2225_34 +# 2234| m2234_13(unknown) = Chi : total:m2225_34, partial:m2234_12 # 2234| v2234_14(void) = ^IndirectReadSideEffect[-1] : &:r2234_9, m2215_8 # 2234| m2234_15(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2234_9 # 2234| m2234_16(ClassWithDestructor) = Chi : total:m2215_8, partial:m2234_15 #-----| Goto -> Block 1 # 2225| Block 20 -# 2225| r2225_62(glval>) = VariableAddress[ys] : -# 2225| r2225_63(glval) = FunctionAddress[~vector] : -# 2225| v2225_64(void) = Call[~vector] : func:r2225_63, this:r2225_62 -# 2225| m2225_65(unknown) = ^CallSideEffect : ~m2225_38 -# 2225| m2225_66(unknown) = Chi : total:m2225_38, partial:m2225_65 -# 2225| v2225_67(void) = ^IndirectReadSideEffect[-1] : &:r2225_62, ~m2225_66 -# 2225| m2225_68(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2225_62 -# 2225| m2225_69(unknown) = Chi : total:m2225_66, partial:m2225_68 +# 2225| r2225_55(glval>) = VariableAddress[ys] : +# 2225| r2225_56(glval) = FunctionAddress[~vector] : +# 2225| v2225_57(void) = Call[~vector] : func:r2225_56, this:r2225_55 +# 2225| v2225_58(void) = ^IndirectReadSideEffect[-1] : &:r2225_55, m2225_6 +# 2225| m2225_59(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2225_55 # 2230| r2230_1(glval>) = VariableAddress[ys] : # 2230| m2230_2(vector) = Uninitialized[ys] : &:r2230_1 -# 2230| m2230_3(unknown) = Chi : total:m2225_69, partial:m2230_2 -# 2230| r2230_4(glval) = FunctionAddress[vector] : -# 2230| r2230_5(glval) = VariableAddress[#temp2230:45] : -# 2230| r2230_6(glval) = VariableAddress[x] : -# 2230| r2230_7(ClassWithDestructor) = Load[x] : &:r2230_6, m2215_8 -# 2230| m2230_8(ClassWithDestructor) = Store[#temp2230:45] : &:r2230_5, r2230_7 -# 2230| r2230_9(ClassWithDestructor) = Load[#temp2230:45] : &:r2230_5, m2230_8 -# 2230| v2230_10(void) = Call[vector] : func:r2230_4, this:r2230_1, 0:r2230_9 -# 2230| m2230_11(unknown) = ^CallSideEffect : ~m2230_3 -# 2230| m2230_12(unknown) = Chi : total:m2230_3, partial:m2230_11 -# 2230| m2230_13(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2230_1 -# 2230| m2230_14(unknown) = Chi : total:m2230_12, partial:m2230_13 -# 2230| r2230_15(glval) = CopyValue : r2230_5 -# 2230| r2230_16(glval) = FunctionAddress[~ClassWithDestructor] : -# 2230| v2230_17(void) = Call[~ClassWithDestructor] : func:r2230_16, this:r2230_15 -# 2230| m2230_18(unknown) = ^CallSideEffect : ~m2230_14 -# 2230| m2230_19(unknown) = Chi : total:m2230_14, partial:m2230_18 -# 2230| v2230_20(void) = ^IndirectReadSideEffect[-1] : &:r2230_15, m2230_8 -# 2230| m2230_21(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2230_15 -# 2230| m2230_22(ClassWithDestructor) = Chi : total:m2230_8, partial:m2230_21 -# 2230| r2230_23(glval &>) = VariableAddress[(__range)] : -# 2230| r2230_24(glval>) = VariableAddress[ys] : -# 2230| r2230_25(vector &) = CopyValue : r2230_24 -# 2230| m2230_26(vector &) = Store[(__range)] : &:r2230_23, r2230_25 -# 2230| r2230_27(glval>) = VariableAddress[(__begin)] : -# 2230| r2230_28(glval &>) = VariableAddress[(__range)] : -# 2230| r2230_29(vector &) = Load[(__range)] : &:r2230_28, m2230_26 -#-----| r0_52(glval>) = CopyValue : r2230_29 +# 2230| r2230_3(glval) = FunctionAddress[vector] : +# 2230| r2230_4(glval) = VariableAddress[#temp2230:45] : +# 2230| r2230_5(glval) = VariableAddress[x] : +# 2230| r2230_6(ClassWithDestructor) = Load[x] : &:r2230_5, m2215_8 +# 2230| m2230_7(ClassWithDestructor) = Store[#temp2230:45] : &:r2230_4, r2230_6 +# 2230| r2230_8(ClassWithDestructor) = Load[#temp2230:45] : &:r2230_4, m2230_7 +# 2230| v2230_9(void) = Call[vector] : func:r2230_3, this:r2230_1, 0:r2230_8 +# 2230| m2230_10(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2230_1 +# 2230| r2230_11(glval) = CopyValue : r2230_4 +# 2230| r2230_12(glval) = FunctionAddress[~ClassWithDestructor] : +# 2230| v2230_13(void) = Call[~ClassWithDestructor] : func:r2230_12, this:r2230_11 +# 2230| m2230_14(unknown) = ^CallSideEffect : ~m2225_34 +# 2230| m2230_15(unknown) = Chi : total:m2225_34, partial:m2230_14 +# 2230| v2230_16(void) = ^IndirectReadSideEffect[-1] : &:r2230_11, m2230_7 +# 2230| m2230_17(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2230_11 +# 2230| m2230_18(ClassWithDestructor) = Chi : total:m2230_7, partial:m2230_17 +# 2230| r2230_19(glval &>) = VariableAddress[(__range)] : +# 2230| r2230_20(glval>) = VariableAddress[ys] : +# 2230| r2230_21(vector &) = CopyValue : r2230_20 +# 2230| m2230_22(vector &) = Store[(__range)] : &:r2230_19, r2230_21 +# 2230| r2230_23(glval>) = VariableAddress[(__begin)] : +# 2230| r2230_24(glval &>) = VariableAddress[(__range)] : +# 2230| r2230_25(vector &) = Load[(__range)] : &:r2230_24, m2230_22 +#-----| r0_52(glval>) = CopyValue : r2230_25 #-----| r0_53(glval>) = Convert : r0_52 -# 2230| r2230_30(glval) = FunctionAddress[begin] : -# 2230| r2230_31(iterator) = Call[begin] : func:r2230_30, this:r0_53 -#-----| v0_54(void) = ^IndirectReadSideEffect[-1] : &:r0_53, ~m2230_19 -# 2230| m2230_32(iterator) = Store[(__begin)] : &:r2230_27, r2230_31 -# 2230| r2230_33(glval>) = VariableAddress[(__end)] : -# 2230| r2230_34(glval &>) = VariableAddress[(__range)] : -# 2230| r2230_35(vector &) = Load[(__range)] : &:r2230_34, m2230_26 -#-----| r0_55(glval>) = CopyValue : r2230_35 +# 2230| r2230_26(glval) = FunctionAddress[begin] : +# 2230| r2230_27(iterator) = Call[begin] : func:r2230_26, this:r0_53 +#-----| v0_54(void) = ^IndirectReadSideEffect[-1] : &:r0_53, m2230_10 +# 2230| m2230_28(iterator) = Store[(__begin)] : &:r2230_23, r2230_27 +# 2230| r2230_29(glval>) = VariableAddress[(__end)] : +# 2230| r2230_30(glval &>) = VariableAddress[(__range)] : +# 2230| r2230_31(vector &) = Load[(__range)] : &:r2230_30, m2230_22 +#-----| r0_55(glval>) = CopyValue : r2230_31 #-----| r0_56(glval>) = Convert : r0_55 -# 2230| r2230_36(glval) = FunctionAddress[end] : -# 2230| r2230_37(iterator) = Call[end] : func:r2230_36, this:r0_56 -#-----| v0_57(void) = ^IndirectReadSideEffect[-1] : &:r0_56, ~m2230_19 -# 2230| m2230_38(iterator) = Store[(__end)] : &:r2230_33, r2230_37 -# 2230| m2230_39(unknown) = Chi : total:m2230_19, partial:m2230_38 +# 2230| r2230_32(glval) = FunctionAddress[end] : +# 2230| r2230_33(iterator) = Call[end] : func:r2230_32, this:r0_56 +#-----| v0_57(void) = ^IndirectReadSideEffect[-1] : &:r0_56, m2230_10 +# 2230| m2230_34(iterator) = Store[(__end)] : &:r2230_29, r2230_33 +# 2230| m2230_35(unknown) = Chi : total:m2230_15, partial:m2230_34 #-----| Goto -> Block 21 # 2230| Block 21 -# 2230| m2230_40(iterator) = Phi : from 20:m2230_32, from 22:m2230_64 -# 2230| m2230_41(unknown) = Phi : from 20:~m2230_39, from 22:~m2230_69 -# 2230| r2230_42(glval>) = VariableAddress[(__begin)] : -#-----| r0_58(glval>) = Convert : r2230_42 -# 2230| r2230_43(glval) = FunctionAddress[operator!=] : +# 2230| m2230_36(iterator) = Phi : from 20:m2230_28, from 22:m2230_60 +# 2230| m2230_37(unknown) = Phi : from 20:~m2230_35, from 22:~m2230_65 +# 2230| r2230_38(glval>) = VariableAddress[(__begin)] : +#-----| r0_58(glval>) = Convert : r2230_38 +# 2230| r2230_39(glval) = FunctionAddress[operator!=] : #-----| r0_59(glval>) = VariableAddress[#temp0:0] : #-----| m0_60(iterator) = Uninitialized[#temp0:0] : &:r0_59 -#-----| m0_61(unknown) = Chi : total:m2230_41, partial:m0_60 -# 2230| r2230_44(glval) = FunctionAddress[iterator] : -# 2230| r2230_45(glval>) = VariableAddress[(__end)] : -#-----| r0_62(glval>) = Convert : r2230_45 +#-----| m0_61(unknown) = Chi : total:m2230_37, partial:m0_60 +# 2230| r2230_40(glval) = FunctionAddress[iterator] : +# 2230| r2230_41(glval>) = VariableAddress[(__end)] : +#-----| r0_62(glval>) = Convert : r2230_41 #-----| r0_63(iterator &) = CopyValue : r0_62 -# 2230| v2230_46(void) = Call[iterator] : func:r2230_44, this:r0_59, 0:r0_63 -# 2230| m2230_47(unknown) = ^CallSideEffect : ~m0_61 -# 2230| m2230_48(unknown) = Chi : total:m0_61, partial:m2230_47 -#-----| v0_64(void) = ^BufferReadSideEffect[0] : &:r0_63, ~m2230_48 -# 2230| m2230_49(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_59 -# 2230| m2230_50(unknown) = Chi : total:m2230_48, partial:m2230_49 -#-----| r0_65(iterator) = Load[#temp0:0] : &:r0_59, ~m2230_50 -# 2230| r2230_51(bool) = Call[operator!=] : func:r2230_43, this:r0_58, 0:r0_65 -#-----| v0_66(void) = ^IndirectReadSideEffect[-1] : &:r0_58, m2230_40 -# 2230| v2230_52(void) = ConditionalBranch : r2230_51 +# 2230| v2230_42(void) = Call[iterator] : func:r2230_40, this:r0_59, 0:r0_63 +# 2230| m2230_43(unknown) = ^CallSideEffect : ~m0_61 +# 2230| m2230_44(unknown) = Chi : total:m0_61, partial:m2230_43 +#-----| v0_64(void) = ^BufferReadSideEffect[0] : &:r0_63, ~m2230_44 +# 2230| m2230_45(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_59 +# 2230| m2230_46(unknown) = Chi : total:m2230_44, partial:m2230_45 +#-----| r0_65(iterator) = Load[#temp0:0] : &:r0_59, ~m2230_46 +# 2230| r2230_47(bool) = Call[operator!=] : func:r2230_39, this:r0_58, 0:r0_65 +#-----| v0_66(void) = ^IndirectReadSideEffect[-1] : &:r0_58, m2230_36 +# 2230| v2230_48(void) = ConditionalBranch : r2230_47 #-----| False -> Block 23 #-----| True -> Block 22 # 2230| Block 22 -# 2230| r2230_53(glval) = VariableAddress[y] : -# 2230| r2230_54(glval>) = VariableAddress[(__begin)] : -#-----| r0_67(glval>) = Convert : r2230_54 -# 2230| r2230_55(glval) = FunctionAddress[operator*] : -# 2230| r2230_56(ClassWithDestructor &) = Call[operator*] : func:r2230_55, this:r0_67 -#-----| v0_68(void) = ^IndirectReadSideEffect[-1] : &:r0_67, m2230_40 -# 2230| r2230_57(ClassWithDestructor) = Load[?] : &:r2230_56, ~m2230_50 -# 2230| m2230_58(ClassWithDestructor) = Store[y] : &:r2230_53, r2230_57 +# 2230| r2230_49(glval) = VariableAddress[y] : +# 2230| r2230_50(glval>) = VariableAddress[(__begin)] : +#-----| r0_67(glval>) = Convert : r2230_50 +# 2230| r2230_51(glval) = FunctionAddress[operator*] : +# 2230| r2230_52(ClassWithDestructor &) = Call[operator*] : func:r2230_51, this:r0_67 +#-----| v0_68(void) = ^IndirectReadSideEffect[-1] : &:r0_67, m2230_36 +# 2230| r2230_53(ClassWithDestructor) = Load[?] : &:r2230_52, ~m2230_46 +# 2230| m2230_54(ClassWithDestructor) = Store[y] : &:r2230_49, r2230_53 # 2231| r2231_1(glval) = VariableAddress[z1] : # 2231| m2231_2(ClassWithDestructor) = Uninitialized[z1] : &:r2231_1 # 2231| r2231_3(glval) = FunctionAddress[ClassWithDestructor] : # 2231| v2231_4(void) = Call[ClassWithDestructor] : func:r2231_3, this:r2231_1 -# 2231| m2231_5(unknown) = ^CallSideEffect : ~m2230_50 -# 2231| m2231_6(unknown) = Chi : total:m2230_50, partial:m2231_5 +# 2231| m2231_5(unknown) = ^CallSideEffect : ~m2230_46 +# 2231| m2231_6(unknown) = Chi : total:m2230_46, partial:m2231_5 # 2231| m2231_7(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2231_1 # 2231| m2231_8(ClassWithDestructor) = Chi : total:m2231_2, partial:m2231_7 # 2232| r2232_1(glval) = VariableAddress[z2] : @@ -16045,38 +16014,35 @@ ir.cpp: # 2233| v2233_14(void) = ^IndirectReadSideEffect[-1] : &:r2233_9, m2231_8 # 2233| m2233_15(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2233_9 # 2233| m2233_16(ClassWithDestructor) = Chi : total:m2231_8, partial:m2233_15 -# 2230| r2230_59(glval>) = VariableAddress[(__begin)] : -# 2230| r2230_60(glval) = FunctionAddress[operator++] : -# 2230| r2230_61(iterator &) = Call[operator++] : func:r2230_60, this:r2230_59 -# 2230| v2230_62(void) = ^IndirectReadSideEffect[-1] : &:r2230_59, m2230_40 -# 2230| m2230_63(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2230_59 -# 2230| m2230_64(iterator) = Chi : total:m2230_40, partial:m2230_63 -# 2230| r2230_65(glval) = VariableAddress[y] : -# 2230| r2230_66(glval) = FunctionAddress[~ClassWithDestructor] : -# 2230| v2230_67(void) = Call[~ClassWithDestructor] : func:r2230_66, this:r2230_65 -# 2230| m2230_68(unknown) = ^CallSideEffect : ~m2233_13 -# 2230| m2230_69(unknown) = Chi : total:m2233_13, partial:m2230_68 -# 2230| v2230_70(void) = ^IndirectReadSideEffect[-1] : &:r2230_65, m2230_58 -# 2230| m2230_71(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2230_65 -# 2230| m2230_72(ClassWithDestructor) = Chi : total:m2230_58, partial:m2230_71 -# 2230| r2230_73(glval>) = CopyValue : r2230_61 +# 2230| r2230_55(glval>) = VariableAddress[(__begin)] : +# 2230| r2230_56(glval) = FunctionAddress[operator++] : +# 2230| r2230_57(iterator &) = Call[operator++] : func:r2230_56, this:r2230_55 +# 2230| v2230_58(void) = ^IndirectReadSideEffect[-1] : &:r2230_55, m2230_36 +# 2230| m2230_59(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2230_55 +# 2230| m2230_60(iterator) = Chi : total:m2230_36, partial:m2230_59 +# 2230| r2230_61(glval) = VariableAddress[y] : +# 2230| r2230_62(glval) = FunctionAddress[~ClassWithDestructor] : +# 2230| v2230_63(void) = Call[~ClassWithDestructor] : func:r2230_62, this:r2230_61 +# 2230| m2230_64(unknown) = ^CallSideEffect : ~m2233_13 +# 2230| m2230_65(unknown) = Chi : total:m2233_13, partial:m2230_64 +# 2230| v2230_66(void) = ^IndirectReadSideEffect[-1] : &:r2230_61, m2230_54 +# 2230| m2230_67(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2230_61 +# 2230| m2230_68(ClassWithDestructor) = Chi : total:m2230_54, partial:m2230_67 +# 2230| r2230_69(glval>) = CopyValue : r2230_57 #-----| Goto (back edge) -> Block 21 # 2230| Block 23 -# 2230| r2230_74(glval>) = VariableAddress[ys] : -# 2230| r2230_75(glval) = FunctionAddress[~vector] : -# 2230| v2230_76(void) = Call[~vector] : func:r2230_75, this:r2230_74 -# 2230| m2230_77(unknown) = ^CallSideEffect : ~m2230_50 -# 2230| m2230_78(unknown) = Chi : total:m2230_50, partial:m2230_77 -# 2230| v2230_79(void) = ^IndirectReadSideEffect[-1] : &:r2230_74, ~m2230_78 -# 2230| m2230_80(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2230_74 -# 2230| m2230_81(unknown) = Chi : total:m2230_78, partial:m2230_80 +# 2230| r2230_70(glval>) = VariableAddress[ys] : +# 2230| r2230_71(glval) = FunctionAddress[~vector] : +# 2230| v2230_72(void) = Call[~vector] : func:r2230_71, this:r2230_70 +# 2230| v2230_73(void) = ^IndirectReadSideEffect[-1] : &:r2230_70, m2230_10 +# 2230| m2230_74(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2230_70 # 2234| v2234_17(void) = NoOp : # 2234| r2234_18(glval) = VariableAddress[x] : # 2234| r2234_19(glval) = FunctionAddress[~ClassWithDestructor] : # 2234| v2234_20(void) = Call[~ClassWithDestructor] : func:r2234_19, this:r2234_18 -# 2234| m2234_21(unknown) = ^CallSideEffect : ~m2230_81 -# 2234| m2234_22(unknown) = Chi : total:m2230_81, partial:m2234_21 +# 2234| m2234_21(unknown) = ^CallSideEffect : ~m2230_46 +# 2234| m2234_22(unknown) = Chi : total:m2230_46, partial:m2234_21 # 2234| v2234_23(void) = ^IndirectReadSideEffect[-1] : &:r2234_18, m2215_8 # 2234| m2234_24(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2234_18 # 2234| m2234_25(ClassWithDestructor) = Chi : total:m2215_8, partial:m2234_24 @@ -16713,116 +16679,112 @@ ir.cpp: #-----| Goto (back edge) -> Block 1 # 2304| Block 3 -# 2304| r2304_31(glval) = VariableAddress[s] : -# 2304| r2304_32(glval) = FunctionAddress[~String] : -# 2304| v2304_33(void) = Call[~String] : func:r2304_32, this:r2304_31 -# 2304| m2304_34(unknown) = ^CallSideEffect : ~m2304_13 -# 2304| m2304_35(unknown) = Chi : total:m2304_13, partial:m2304_34 -# 2304| v2304_36(void) = ^IndirectReadSideEffect[-1] : &:r2304_31, ~m2304_35 -# 2304| m2304_37(String) = ^IndirectMayWriteSideEffect[-1] : &:r2304_31 -# 2304| m2304_38(unknown) = Chi : total:m2304_35, partial:m2304_37 -# 2308| r2308_1(glval &&>) = VariableAddress[(__range)] : -# 2308| r2308_2(glval>) = VariableAddress[#temp2308:20] : -# 2308| m2308_3(vector) = Uninitialized[#temp2308:20] : &:r2308_2 -# 2308| m2308_4(unknown) = Chi : total:m2304_38, partial:m2308_3 -# 2308| r2308_5(glval) = FunctionAddress[vector] : -# 2308| r2308_6(glval) = VariableAddress[#temp2308:40] : -# 2308| m2308_7(String) = Uninitialized[#temp2308:40] : &:r2308_6 -# 2308| m2308_8(unknown) = Chi : total:m2308_4, partial:m2308_7 -# 2308| r2308_9(glval) = FunctionAddress[String] : -# 2308| r2308_10(glval) = StringConstant["hello"] : -# 2308| r2308_11(char *) = Convert : r2308_10 -# 2308| v2308_12(void) = Call[String] : func:r2308_9, this:r2308_6, 0:r2308_11 -# 2308| m2308_13(unknown) = ^CallSideEffect : ~m2308_8 -# 2308| m2308_14(unknown) = Chi : total:m2308_8, partial:m2308_13 -# 2308| v2308_15(void) = ^BufferReadSideEffect[0] : &:r2308_11, ~m2302_3 -# 2308| m2308_16(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_6 -# 2308| m2308_17(unknown) = Chi : total:m2308_14, partial:m2308_16 -# 2308| r2308_18(String) = Load[#temp2308:40] : &:r2308_6, ~m2308_17 -# 2308| v2308_19(void) = Call[vector] : func:r2308_5, this:r2308_2, 0:r2308_18 -# 2308| m2308_20(unknown) = ^CallSideEffect : ~m2308_17 -# 2308| m2308_21(unknown) = Chi : total:m2308_17, partial:m2308_20 -# 2308| m2308_22(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2308_2 -# 2308| m2308_23(unknown) = Chi : total:m2308_21, partial:m2308_22 -# 2308| r2308_24(glval) = CopyValue : r2308_6 -# 2308| r2308_25(glval) = FunctionAddress[~String] : -# 2308| v2308_26(void) = Call[~String] : func:r2308_25, this:r2308_24 -# 2308| m2308_27(unknown) = ^CallSideEffect : ~m2308_23 -# 2308| m2308_28(unknown) = Chi : total:m2308_23, partial:m2308_27 -# 2308| v2308_29(void) = ^IndirectReadSideEffect[-1] : &:r2308_24, ~m2308_28 -# 2308| m2308_30(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_24 -# 2308| m2308_31(unknown) = Chi : total:m2308_28, partial:m2308_30 -# 2308| r2308_32(vector &) = CopyValue : r2308_2 -# 2308| m2308_33(vector &&) = Store[(__range)] : &:r2308_1, r2308_32 -# 2308| r2308_34(glval>) = VariableAddress[(__begin)] : -# 2308| r2308_35(glval &&>) = VariableAddress[(__range)] : -# 2308| r2308_36(vector &&) = Load[(__range)] : &:r2308_35, m2308_33 -#-----| r0_1(glval>) = CopyValue : r2308_36 -#-----| r0_2(glval>) = Convert : r0_1 -# 2308| r2308_37(glval) = FunctionAddress[begin] : -# 2308| r2308_38(iterator) = Call[begin] : func:r2308_37, this:r0_2 -#-----| v0_3(void) = ^IndirectReadSideEffect[-1] : &:r0_2, ~m2308_28 -# 2308| m2308_39(iterator) = Store[(__begin)] : &:r2308_34, r2308_38 -# 2308| r2308_40(glval>) = VariableAddress[(__end)] : -# 2308| r2308_41(glval &&>) = VariableAddress[(__range)] : -# 2308| r2308_42(vector &&) = Load[(__range)] : &:r2308_41, m2308_33 -#-----| r0_4(glval>) = CopyValue : r2308_42 -#-----| r0_5(glval>) = Convert : r0_4 -# 2308| r2308_43(glval) = FunctionAddress[end] : -# 2308| r2308_44(iterator) = Call[end] : func:r2308_43, this:r0_5 -#-----| v0_6(void) = ^IndirectReadSideEffect[-1] : &:r0_5, ~m2308_28 -# 2308| m2308_45(iterator) = Store[(__end)] : &:r2308_40, r2308_44 -# 2308| m2308_46(unknown) = Chi : total:m2308_31, partial:m2308_45 +# 2304| r2304_31(glval) = VariableAddress[s] : +# 2304| r2304_32(glval) = FunctionAddress[~String] : +# 2304| v2304_33(void) = Call[~String] : func:r2304_32, this:r2304_31 +# 2304| m2304_34(unknown) = ^CallSideEffect : ~m2304_13 +# 2304| m2304_35(unknown) = Chi : total:m2304_13, partial:m2304_34 +# 2304| v2304_36(void) = ^IndirectReadSideEffect[-1] : &:r2304_31, ~m2304_35 +# 2304| m2304_37(String) = ^IndirectMayWriteSideEffect[-1] : &:r2304_31 +# 2304| m2304_38(unknown) = Chi : total:m2304_35, partial:m2304_37 +# 2308| r2308_1(glval &&>) = VariableAddress[(__range)] : +# 2308| r2308_2(glval>) = VariableAddress[#temp2308:20] : +# 2308| m2308_3(vector) = Uninitialized[#temp2308:20] : &:r2308_2 +# 2308| r2308_4(glval) = FunctionAddress[vector] : +# 2308| r2308_5(glval) = VariableAddress[#temp2308:40] : +# 2308| m2308_6(String) = Uninitialized[#temp2308:40] : &:r2308_5 +# 2308| m2308_7(unknown) = Chi : total:m2304_38, partial:m2308_6 +# 2308| r2308_8(glval) = FunctionAddress[String] : +# 2308| r2308_9(glval) = StringConstant["hello"] : +# 2308| r2308_10(char *) = Convert : r2308_9 +# 2308| v2308_11(void) = Call[String] : func:r2308_8, this:r2308_5, 0:r2308_10 +# 2308| m2308_12(unknown) = ^CallSideEffect : ~m2308_7 +# 2308| m2308_13(unknown) = Chi : total:m2308_7, partial:m2308_12 +# 2308| v2308_14(void) = ^BufferReadSideEffect[0] : &:r2308_10, ~m2302_3 +# 2308| m2308_15(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_5 +# 2308| m2308_16(unknown) = Chi : total:m2308_13, partial:m2308_15 +# 2308| r2308_17(String) = Load[#temp2308:40] : &:r2308_5, ~m2308_16 +# 2308| v2308_18(void) = Call[vector] : func:r2308_4, this:r2308_2, 0:r2308_17 +# 2308| m2308_19(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2308_2 +# 2308| r2308_20(glval) = CopyValue : r2308_5 +# 2308| r2308_21(glval) = FunctionAddress[~String] : +# 2308| v2308_22(void) = Call[~String] : func:r2308_21, this:r2308_20 +# 2308| m2308_23(unknown) = ^CallSideEffect : ~m2308_16 +# 2308| m2308_24(unknown) = Chi : total:m2308_16, partial:m2308_23 +# 2308| v2308_25(void) = ^IndirectReadSideEffect[-1] : &:r2308_20, ~m2308_24 +# 2308| m2308_26(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_20 +# 2308| m2308_27(unknown) = Chi : total:m2308_24, partial:m2308_26 +# 2308| r2308_28(vector &) = CopyValue : r2308_2 +# 2308| m2308_29(vector &&) = Store[(__range)] : &:r2308_1, r2308_28 +# 2308| r2308_30(glval>) = VariableAddress[(__begin)] : +# 2308| r2308_31(glval &&>) = VariableAddress[(__range)] : +# 2308| r2308_32(vector &&) = Load[(__range)] : &:r2308_31, m2308_29 +#-----| r0_1(glval>) = CopyValue : r2308_32 +#-----| r0_2(glval>) = Convert : r0_1 +# 2308| r2308_33(glval) = FunctionAddress[begin] : +# 2308| r2308_34(iterator) = Call[begin] : func:r2308_33, this:r0_2 +#-----| v0_3(void) = ^IndirectReadSideEffect[-1] : &:r0_2, m2308_19 +# 2308| m2308_35(iterator) = Store[(__begin)] : &:r2308_30, r2308_34 +# 2308| r2308_36(glval>) = VariableAddress[(__end)] : +# 2308| r2308_37(glval &&>) = VariableAddress[(__range)] : +# 2308| r2308_38(vector &&) = Load[(__range)] : &:r2308_37, m2308_29 +#-----| r0_4(glval>) = CopyValue : r2308_38 +#-----| r0_5(glval>) = Convert : r0_4 +# 2308| r2308_39(glval) = FunctionAddress[end] : +# 2308| r2308_40(iterator) = Call[end] : func:r2308_39, this:r0_5 +#-----| v0_6(void) = ^IndirectReadSideEffect[-1] : &:r0_5, m2308_19 +# 2308| m2308_41(iterator) = Store[(__end)] : &:r2308_36, r2308_40 +# 2308| m2308_42(unknown) = Chi : total:m2308_27, partial:m2308_41 #-----| Goto -> Block 4 # 2308| Block 4 -# 2308| m2308_47(iterator) = Phi : from 3:m2308_39, from 5:m2308_81 -# 2308| m2308_48(unknown) = Phi : from 3:~m2308_46, from 5:~m2308_89 -# 2308| r2308_49(glval>) = VariableAddress[(__begin)] : -#-----| r0_7(glval>) = Convert : r2308_49 -# 2308| r2308_50(glval) = FunctionAddress[operator!=] : +# 2308| m2308_43(iterator) = Phi : from 3:m2308_35, from 5:m2308_77 +# 2308| m2308_44(unknown) = Phi : from 3:~m2308_42, from 5:~m2308_85 +# 2308| r2308_45(glval>) = VariableAddress[(__begin)] : +#-----| r0_7(glval>) = Convert : r2308_45 +# 2308| r2308_46(glval) = FunctionAddress[operator!=] : #-----| r0_8(glval>) = VariableAddress[#temp0:0] : #-----| m0_9(iterator) = Uninitialized[#temp0:0] : &:r0_8 -#-----| m0_10(unknown) = Chi : total:m2308_48, partial:m0_9 -# 2308| r2308_51(glval) = FunctionAddress[iterator] : -# 2308| r2308_52(glval>) = VariableAddress[(__end)] : -#-----| r0_11(glval>) = Convert : r2308_52 +#-----| m0_10(unknown) = Chi : total:m2308_44, partial:m0_9 +# 2308| r2308_47(glval) = FunctionAddress[iterator] : +# 2308| r2308_48(glval>) = VariableAddress[(__end)] : +#-----| r0_11(glval>) = Convert : r2308_48 #-----| r0_12(iterator &) = CopyValue : r0_11 -# 2308| v2308_53(void) = Call[iterator] : func:r2308_51, this:r0_8, 0:r0_12 -# 2308| m2308_54(unknown) = ^CallSideEffect : ~m0_10 -# 2308| m2308_55(unknown) = Chi : total:m0_10, partial:m2308_54 -#-----| v0_13(void) = ^BufferReadSideEffect[0] : &:r0_12, ~m2308_55 -# 2308| m2308_56(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 -# 2308| m2308_57(unknown) = Chi : total:m2308_55, partial:m2308_56 -#-----| r0_14(iterator) = Load[#temp0:0] : &:r0_8, ~m2308_57 -# 2308| r2308_58(bool) = Call[operator!=] : func:r2308_50, this:r0_7, 0:r0_14 -#-----| v0_15(void) = ^IndirectReadSideEffect[-1] : &:r0_7, m2308_47 -# 2308| v2308_59(void) = ConditionalBranch : r2308_58 +# 2308| v2308_49(void) = Call[iterator] : func:r2308_47, this:r0_8, 0:r0_12 +# 2308| m2308_50(unknown) = ^CallSideEffect : ~m0_10 +# 2308| m2308_51(unknown) = Chi : total:m0_10, partial:m2308_50 +#-----| v0_13(void) = ^BufferReadSideEffect[0] : &:r0_12, ~m2308_51 +# 2308| m2308_52(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 +# 2308| m2308_53(unknown) = Chi : total:m2308_51, partial:m2308_52 +#-----| r0_14(iterator) = Load[#temp0:0] : &:r0_8, ~m2308_53 +# 2308| r2308_54(bool) = Call[operator!=] : func:r2308_46, this:r0_7, 0:r0_14 +#-----| v0_15(void) = ^IndirectReadSideEffect[-1] : &:r0_7, m2308_43 +# 2308| v2308_55(void) = ConditionalBranch : r2308_54 #-----| False -> Block 6 #-----| True -> Block 5 # 2308| Block 5 -# 2308| r2308_60(glval) = VariableAddress[s] : -# 2308| m2308_61(String) = Uninitialized[s] : &:r2308_60 -# 2308| m2308_62(unknown) = Chi : total:m2308_57, partial:m2308_61 -# 2308| r2308_63(glval) = FunctionAddress[String] : -# 2308| r2308_64(glval>) = VariableAddress[(__begin)] : -#-----| r0_16(glval>) = Convert : r2308_64 -# 2308| r2308_65(glval) = FunctionAddress[operator*] : -# 2308| r2308_66(String &) = Call[operator*] : func:r2308_65, this:r0_16 -#-----| v0_17(void) = ^IndirectReadSideEffect[-1] : &:r0_16, m2308_47 -# 2308| r2308_67(glval) = CopyValue : r2308_66 -# 2308| r2308_68(glval) = Convert : r2308_67 -# 2308| r2308_69(String &) = CopyValue : r2308_68 -# 2308| v2308_70(void) = Call[String] : func:r2308_63, this:r2308_60, 0:r2308_69 -# 2308| m2308_71(unknown) = ^CallSideEffect : ~m2308_62 -# 2308| m2308_72(unknown) = Chi : total:m2308_62, partial:m2308_71 -# 2308| v2308_73(void) = ^BufferReadSideEffect[0] : &:r2308_69, ~m2308_72 -# 2308| m2308_74(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_60 -# 2308| m2308_75(unknown) = Chi : total:m2308_72, partial:m2308_74 +# 2308| r2308_56(glval) = VariableAddress[s] : +# 2308| m2308_57(String) = Uninitialized[s] : &:r2308_56 +# 2308| m2308_58(unknown) = Chi : total:m2308_53, partial:m2308_57 +# 2308| r2308_59(glval) = FunctionAddress[String] : +# 2308| r2308_60(glval>) = VariableAddress[(__begin)] : +#-----| r0_16(glval>) = Convert : r2308_60 +# 2308| r2308_61(glval) = FunctionAddress[operator*] : +# 2308| r2308_62(String &) = Call[operator*] : func:r2308_61, this:r0_16 +#-----| v0_17(void) = ^IndirectReadSideEffect[-1] : &:r0_16, m2308_43 +# 2308| r2308_63(glval) = CopyValue : r2308_62 +# 2308| r2308_64(glval) = Convert : r2308_63 +# 2308| r2308_65(String &) = CopyValue : r2308_64 +# 2308| v2308_66(void) = Call[String] : func:r2308_59, this:r2308_56, 0:r2308_65 +# 2308| m2308_67(unknown) = ^CallSideEffect : ~m2308_58 +# 2308| m2308_68(unknown) = Chi : total:m2308_58, partial:m2308_67 +# 2308| v2308_69(void) = ^BufferReadSideEffect[0] : &:r2308_65, ~m2308_68 +# 2308| m2308_70(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_56 +# 2308| m2308_71(unknown) = Chi : total:m2308_68, partial:m2308_70 # 2309| r2309_1(glval) = VariableAddress[s2] : # 2309| m2309_2(String) = Uninitialized[s2] : &:r2309_1 -# 2309| m2309_3(unknown) = Chi : total:m2308_75, partial:m2309_2 +# 2309| m2309_3(unknown) = Chi : total:m2308_71, partial:m2309_2 # 2309| r2309_4(glval) = FunctionAddress[String] : # 2309| v2309_5(void) = Call[String] : func:r2309_4, this:r2309_1 # 2309| m2309_6(unknown) = ^CallSideEffect : ~m2309_3 @@ -16837,56 +16799,53 @@ ir.cpp: # 2310| v2310_6(void) = ^IndirectReadSideEffect[-1] : &:r2310_1, ~m2310_5 # 2310| m2310_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r2310_1 # 2310| m2310_8(unknown) = Chi : total:m2310_5, partial:m2310_7 -# 2308| r2308_76(glval>) = VariableAddress[(__begin)] : -# 2308| r2308_77(glval) = FunctionAddress[operator++] : -# 2308| r2308_78(iterator &) = Call[operator++] : func:r2308_77, this:r2308_76 -# 2308| v2308_79(void) = ^IndirectReadSideEffect[-1] : &:r2308_76, m2308_47 -# 2308| m2308_80(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2308_76 -# 2308| m2308_81(iterator) = Chi : total:m2308_47, partial:m2308_80 -# 2308| r2308_82(glval) = VariableAddress[s] : -# 2308| r2308_83(glval) = FunctionAddress[~String] : -# 2308| v2308_84(void) = Call[~String] : func:r2308_83, this:r2308_82 -# 2308| m2308_85(unknown) = ^CallSideEffect : ~m2310_8 -# 2308| m2308_86(unknown) = Chi : total:m2310_8, partial:m2308_85 -# 2308| v2308_87(void) = ^IndirectReadSideEffect[-1] : &:r2308_82, ~m2308_86 -# 2308| m2308_88(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_82 -# 2308| m2308_89(unknown) = Chi : total:m2308_86, partial:m2308_88 -# 2308| r2308_90(glval>) = CopyValue : r2308_78 +# 2308| r2308_72(glval>) = VariableAddress[(__begin)] : +# 2308| r2308_73(glval) = FunctionAddress[operator++] : +# 2308| r2308_74(iterator &) = Call[operator++] : func:r2308_73, this:r2308_72 +# 2308| v2308_75(void) = ^IndirectReadSideEffect[-1] : &:r2308_72, m2308_43 +# 2308| m2308_76(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2308_72 +# 2308| m2308_77(iterator) = Chi : total:m2308_43, partial:m2308_76 +# 2308| r2308_78(glval) = VariableAddress[s] : +# 2308| r2308_79(glval) = FunctionAddress[~String] : +# 2308| v2308_80(void) = Call[~String] : func:r2308_79, this:r2308_78 +# 2308| m2308_81(unknown) = ^CallSideEffect : ~m2310_8 +# 2308| m2308_82(unknown) = Chi : total:m2310_8, partial:m2308_81 +# 2308| v2308_83(void) = ^IndirectReadSideEffect[-1] : &:r2308_78, ~m2308_82 +# 2308| m2308_84(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_78 +# 2308| m2308_85(unknown) = Chi : total:m2308_82, partial:m2308_84 +# 2308| r2308_86(glval>) = CopyValue : r2308_74 #-----| Goto (back edge) -> Block 4 # 2308| Block 6 -# 2308| r2308_91(glval>) = CopyValue : r2308_2 -# 2308| r2308_92(glval) = FunctionAddress[~vector] : -# 2308| v2308_93(void) = Call[~vector] : func:r2308_92, this:r2308_91 -# 2308| m2308_94(unknown) = ^CallSideEffect : ~m2308_57 -# 2308| m2308_95(unknown) = Chi : total:m2308_57, partial:m2308_94 -# 2308| v2308_96(void) = ^IndirectReadSideEffect[-1] : &:r2308_91, ~m2308_95 -# 2308| m2308_97(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2308_91 -# 2308| m2308_98(unknown) = Chi : total:m2308_95, partial:m2308_97 -# 2312| r2312_1(glval) = VariableAddress[s] : -# 2312| m2312_2(String) = Uninitialized[s] : &:r2312_1 -# 2312| m2312_3(unknown) = Chi : total:m2308_98, partial:m2312_2 -# 2312| r2312_4(glval) = FunctionAddress[String] : -# 2312| r2312_5(glval) = StringConstant["hello"] : -# 2312| r2312_6(char *) = Convert : r2312_5 -# 2312| v2312_7(void) = Call[String] : func:r2312_4, this:r2312_1, 0:r2312_6 -# 2312| m2312_8(unknown) = ^CallSideEffect : ~m2312_3 -# 2312| m2312_9(unknown) = Chi : total:m2312_3, partial:m2312_8 -# 2312| v2312_10(void) = ^BufferReadSideEffect[0] : &:r2312_6, ~m2302_3 -# 2312| m2312_11(String) = ^IndirectMayWriteSideEffect[-1] : &:r2312_1 -# 2312| m2312_12(unknown) = Chi : total:m2312_9, partial:m2312_11 -# 2312| r2312_13(glval) = VariableAddress[s2] : -# 2312| m2312_14(String) = Uninitialized[s2] : &:r2312_13 -# 2312| m2312_15(unknown) = Chi : total:m2312_12, partial:m2312_14 -# 2312| r2312_16(glval) = FunctionAddress[String] : -# 2312| r2312_17(glval) = StringConstant["world"] : -# 2312| r2312_18(char *) = Convert : r2312_17 -# 2312| v2312_19(void) = Call[String] : func:r2312_16, this:r2312_13, 0:r2312_18 -# 2312| m2312_20(unknown) = ^CallSideEffect : ~m2312_15 -# 2312| m2312_21(unknown) = Chi : total:m2312_15, partial:m2312_20 -# 2312| v2312_22(void) = ^BufferReadSideEffect[0] : &:r2312_18, ~m2302_3 -# 2312| m2312_23(String) = ^IndirectMayWriteSideEffect[-1] : &:r2312_13 -# 2312| m2312_24(unknown) = Chi : total:m2312_21, partial:m2312_23 +# 2308| r2308_87(glval>) = CopyValue : r2308_2 +# 2308| r2308_88(glval) = FunctionAddress[~vector] : +# 2308| v2308_89(void) = Call[~vector] : func:r2308_88, this:r2308_87 +# 2308| v2308_90(void) = ^IndirectReadSideEffect[-1] : &:r2308_87, m2308_19 +# 2308| m2308_91(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2308_87 +# 2312| r2312_1(glval) = VariableAddress[s] : +# 2312| m2312_2(String) = Uninitialized[s] : &:r2312_1 +# 2312| m2312_3(unknown) = Chi : total:m2308_53, partial:m2312_2 +# 2312| r2312_4(glval) = FunctionAddress[String] : +# 2312| r2312_5(glval) = StringConstant["hello"] : +# 2312| r2312_6(char *) = Convert : r2312_5 +# 2312| v2312_7(void) = Call[String] : func:r2312_4, this:r2312_1, 0:r2312_6 +# 2312| m2312_8(unknown) = ^CallSideEffect : ~m2312_3 +# 2312| m2312_9(unknown) = Chi : total:m2312_3, partial:m2312_8 +# 2312| v2312_10(void) = ^BufferReadSideEffect[0] : &:r2312_6, ~m2302_3 +# 2312| m2312_11(String) = ^IndirectMayWriteSideEffect[-1] : &:r2312_1 +# 2312| m2312_12(unknown) = Chi : total:m2312_9, partial:m2312_11 +# 2312| r2312_13(glval) = VariableAddress[s2] : +# 2312| m2312_14(String) = Uninitialized[s2] : &:r2312_13 +# 2312| m2312_15(unknown) = Chi : total:m2312_12, partial:m2312_14 +# 2312| r2312_16(glval) = FunctionAddress[String] : +# 2312| r2312_17(glval) = StringConstant["world"] : +# 2312| r2312_18(char *) = Convert : r2312_17 +# 2312| v2312_19(void) = Call[String] : func:r2312_16, this:r2312_13, 0:r2312_18 +# 2312| m2312_20(unknown) = ^CallSideEffect : ~m2312_15 +# 2312| m2312_21(unknown) = Chi : total:m2312_15, partial:m2312_20 +# 2312| v2312_22(void) = ^BufferReadSideEffect[0] : &:r2312_18, ~m2302_3 +# 2312| m2312_23(String) = ^IndirectMayWriteSideEffect[-1] : &:r2312_13 +# 2312| m2312_24(unknown) = Chi : total:m2312_21, partial:m2312_23 #-----| Goto -> Block 7 # 2312| Block 7 @@ -17640,104 +17599,97 @@ ir.cpp: # 2431| r2431_26(glval &&>) = VariableAddress[(__range)] : # 2431| r2431_27(glval>) = VariableAddress[#temp2431:58] : # 2431| m2431_28(vector) = Uninitialized[#temp2431:58] : &:r2431_27 -# 2431| m2431_29(unknown) = Chi : total:m2431_21, partial:m2431_28 -# 2431| r2431_30(glval) = FunctionAddress[vector] : -# 2431| r2431_31(glval) = VariableAddress[x] : -# 2431| r2431_32(char) = Load[x] : &:r2431_31, m2431_25 -# 2431| v2431_33(void) = Call[vector] : func:r2431_30, this:r2431_27, 0:r2431_32 -# 2431| m2431_34(unknown) = ^CallSideEffect : ~m2431_29 -# 2431| m2431_35(unknown) = Chi : total:m2431_29, partial:m2431_34 -# 2431| m2431_36(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2431_27 -# 2431| m2431_37(unknown) = Chi : total:m2431_35, partial:m2431_36 -# 2431| r2431_38(vector &) = CopyValue : r2431_27 -# 2431| m2431_39(vector &&) = Store[(__range)] : &:r2431_26, r2431_38 -# 2431| r2431_40(glval>) = VariableAddress[(__begin)] : -# 2431| r2431_41(glval &&>) = VariableAddress[(__range)] : -# 2431| r2431_42(vector &&) = Load[(__range)] : &:r2431_41, m2431_39 -#-----| r0_1(glval>) = CopyValue : r2431_42 +# 2431| r2431_29(glval) = FunctionAddress[vector] : +# 2431| r2431_30(glval) = VariableAddress[x] : +# 2431| r2431_31(char) = Load[x] : &:r2431_30, m2431_25 +# 2431| v2431_32(void) = Call[vector] : func:r2431_29, this:r2431_27, 0:r2431_31 +# 2431| m2431_33(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2431_27 +# 2431| r2431_34(vector &) = CopyValue : r2431_27 +# 2431| m2431_35(vector &&) = Store[(__range)] : &:r2431_26, r2431_34 +# 2431| r2431_36(glval>) = VariableAddress[(__begin)] : +# 2431| r2431_37(glval &&>) = VariableAddress[(__range)] : +# 2431| r2431_38(vector &&) = Load[(__range)] : &:r2431_37, m2431_35 +#-----| r0_1(glval>) = CopyValue : r2431_38 #-----| r0_2(glval>) = Convert : r0_1 -# 2431| r2431_43(glval) = FunctionAddress[begin] : -# 2431| r2431_44(iterator) = Call[begin] : func:r2431_43, this:r0_2 -#-----| v0_3(void) = ^IndirectReadSideEffect[-1] : &:r0_2, ~m2431_37 -# 2431| m2431_45(iterator) = Store[(__begin)] : &:r2431_40, r2431_44 -# 2431| r2431_46(glval>) = VariableAddress[(__end)] : -# 2431| r2431_47(glval &&>) = VariableAddress[(__range)] : -# 2431| r2431_48(vector &&) = Load[(__range)] : &:r2431_47, m2431_39 -#-----| r0_4(glval>) = CopyValue : r2431_48 +# 2431| r2431_39(glval) = FunctionAddress[begin] : +# 2431| r2431_40(iterator) = Call[begin] : func:r2431_39, this:r0_2 +#-----| v0_3(void) = ^IndirectReadSideEffect[-1] : &:r0_2, m2431_33 +# 2431| m2431_41(iterator) = Store[(__begin)] : &:r2431_36, r2431_40 +# 2431| r2431_42(glval>) = VariableAddress[(__end)] : +# 2431| r2431_43(glval &&>) = VariableAddress[(__range)] : +# 2431| r2431_44(vector &&) = Load[(__range)] : &:r2431_43, m2431_35 +#-----| r0_4(glval>) = CopyValue : r2431_44 #-----| r0_5(glval>) = Convert : r0_4 -# 2431| r2431_49(glval) = FunctionAddress[end] : -# 2431| r2431_50(iterator) = Call[end] : func:r2431_49, this:r0_5 -#-----| v0_6(void) = ^IndirectReadSideEffect[-1] : &:r0_5, ~m2431_37 -# 2431| m2431_51(iterator) = Store[(__end)] : &:r2431_46, r2431_50 -# 2431| m2431_52(unknown) = Chi : total:m2431_37, partial:m2431_51 +# 2431| r2431_45(glval) = FunctionAddress[end] : +# 2431| r2431_46(iterator) = Call[end] : func:r2431_45, this:r0_5 +#-----| v0_6(void) = ^IndirectReadSideEffect[-1] : &:r0_5, m2431_33 +# 2431| m2431_47(iterator) = Store[(__end)] : &:r2431_42, r2431_46 +# 2431| m2431_48(unknown) = Chi : total:m2431_21, partial:m2431_47 #-----| Goto -> Block 10 # 2431| Block 10 -# 2431| m2431_53(iterator) = Phi : from 9:m2431_45, from 11:m2431_77 -# 2431| m2431_54(unknown) = Phi : from 9:~m2431_52, from 11:~m2431_63 -# 2431| r2431_55(glval>) = VariableAddress[(__begin)] : -#-----| r0_7(glval>) = Convert : r2431_55 -# 2431| r2431_56(glval) = FunctionAddress[operator!=] : +# 2431| m2431_49(iterator) = Phi : from 9:m2431_41, from 11:m2431_73 +# 2431| m2431_50(unknown) = Phi : from 9:~m2431_48, from 11:~m2431_59 +# 2431| r2431_51(glval>) = VariableAddress[(__begin)] : +#-----| r0_7(glval>) = Convert : r2431_51 +# 2431| r2431_52(glval) = FunctionAddress[operator!=] : #-----| r0_8(glval>) = VariableAddress[#temp0:0] : #-----| m0_9(iterator) = Uninitialized[#temp0:0] : &:r0_8 -#-----| m0_10(unknown) = Chi : total:m2431_54, partial:m0_9 -# 2431| r2431_57(glval) = FunctionAddress[iterator] : -# 2431| r2431_58(glval>) = VariableAddress[(__end)] : -#-----| r0_11(glval>) = Convert : r2431_58 +#-----| m0_10(unknown) = Chi : total:m2431_50, partial:m0_9 +# 2431| r2431_53(glval) = FunctionAddress[iterator] : +# 2431| r2431_54(glval>) = VariableAddress[(__end)] : +#-----| r0_11(glval>) = Convert : r2431_54 #-----| r0_12(iterator &) = CopyValue : r0_11 -# 2431| v2431_59(void) = Call[iterator] : func:r2431_57, this:r0_8, 0:r0_12 -# 2431| m2431_60(unknown) = ^CallSideEffect : ~m0_10 -# 2431| m2431_61(unknown) = Chi : total:m0_10, partial:m2431_60 -#-----| v0_13(void) = ^BufferReadSideEffect[0] : &:r0_12, ~m2431_61 -# 2431| m2431_62(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 -# 2431| m2431_63(unknown) = Chi : total:m2431_61, partial:m2431_62 -#-----| r0_14(iterator) = Load[#temp0:0] : &:r0_8, ~m2431_63 -# 2431| r2431_64(bool) = Call[operator!=] : func:r2431_56, this:r0_7, 0:r0_14 -#-----| v0_15(void) = ^IndirectReadSideEffect[-1] : &:r0_7, m2431_53 -# 2431| v2431_65(void) = ConditionalBranch : r2431_64 +# 2431| v2431_55(void) = Call[iterator] : func:r2431_53, this:r0_8, 0:r0_12 +# 2431| m2431_56(unknown) = ^CallSideEffect : ~m0_10 +# 2431| m2431_57(unknown) = Chi : total:m0_10, partial:m2431_56 +#-----| v0_13(void) = ^BufferReadSideEffect[0] : &:r0_12, ~m2431_57 +# 2431| m2431_58(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 +# 2431| m2431_59(unknown) = Chi : total:m2431_57, partial:m2431_58 +#-----| r0_14(iterator) = Load[#temp0:0] : &:r0_8, ~m2431_59 +# 2431| r2431_60(bool) = Call[operator!=] : func:r2431_52, this:r0_7, 0:r0_14 +#-----| v0_15(void) = ^IndirectReadSideEffect[-1] : &:r0_7, m2431_49 +# 2431| v2431_61(void) = ConditionalBranch : r2431_60 #-----| False -> Block 12 #-----| True -> Block 11 # 2431| Block 11 -# 2431| r2431_66(glval) = VariableAddress[y] : -# 2431| r2431_67(glval>) = VariableAddress[(__begin)] : -#-----| r0_16(glval>) = Convert : r2431_67 -# 2431| r2431_68(glval) = FunctionAddress[operator*] : -# 2431| r2431_69(char &) = Call[operator*] : func:r2431_68, this:r0_16 -#-----| v0_17(void) = ^IndirectReadSideEffect[-1] : &:r0_16, m2431_53 -# 2431| r2431_70(char) = Load[?] : &:r2431_69, ~m2431_63 -# 2431| m2431_71(char) = Store[y] : &:r2431_66, r2431_70 +# 2431| r2431_62(glval) = VariableAddress[y] : +# 2431| r2431_63(glval>) = VariableAddress[(__begin)] : +#-----| r0_16(glval>) = Convert : r2431_63 +# 2431| r2431_64(glval) = FunctionAddress[operator*] : +# 2431| r2431_65(char &) = Call[operator*] : func:r2431_64, this:r0_16 +#-----| v0_17(void) = ^IndirectReadSideEffect[-1] : &:r0_16, m2431_49 +# 2431| r2431_66(char) = Load[?] : &:r2431_65, ~m2431_59 +# 2431| m2431_67(char) = Store[y] : &:r2431_62, r2431_66 # 2432| r2432_1(glval) = VariableAddress[x] : # 2432| r2432_2(char) = Load[x] : &:r2432_1, m2431_25 # 2432| r2432_3(int) = Convert : r2432_2 # 2432| r2432_4(glval) = VariableAddress[y] : -# 2432| r2432_5(char) = Load[y] : &:r2432_4, m2431_71 +# 2432| r2432_5(char) = Load[y] : &:r2432_4, m2431_67 # 2432| r2432_6(int) = Convert : r2432_5 # 2432| r2432_7(int) = Add : r2432_6, r2432_3 # 2432| r2432_8(char) = Convert : r2432_7 # 2432| m2432_9(char) = Store[y] : &:r2432_4, r2432_8 -# 2431| r2431_72(glval>) = VariableAddress[(__begin)] : -# 2431| r2431_73(glval) = FunctionAddress[operator++] : -# 2431| r2431_74(iterator &) = Call[operator++] : func:r2431_73, this:r2431_72 -# 2431| v2431_75(void) = ^IndirectReadSideEffect[-1] : &:r2431_72, m2431_53 -# 2431| m2431_76(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2431_72 -# 2431| m2431_77(iterator) = Chi : total:m2431_53, partial:m2431_76 -# 2431| r2431_78(glval>) = CopyValue : r2431_74 +# 2431| r2431_68(glval>) = VariableAddress[(__begin)] : +# 2431| r2431_69(glval) = FunctionAddress[operator++] : +# 2431| r2431_70(iterator &) = Call[operator++] : func:r2431_69, this:r2431_68 +# 2431| v2431_71(void) = ^IndirectReadSideEffect[-1] : &:r2431_68, m2431_49 +# 2431| m2431_72(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2431_68 +# 2431| m2431_73(iterator) = Chi : total:m2431_49, partial:m2431_72 +# 2431| r2431_74(glval>) = CopyValue : r2431_70 #-----| Goto (back edge) -> Block 10 # 2431| Block 12 -# 2431| r2431_79(glval>) = CopyValue : r2431_27 -# 2431| r2431_80(glval) = FunctionAddress[~vector] : -# 2431| v2431_81(void) = Call[~vector] : func:r2431_80, this:r2431_79 -# 2431| m2431_82(unknown) = ^CallSideEffect : ~m2431_63 -# 2431| m2431_83(unknown) = Chi : total:m2431_63, partial:m2431_82 -# 2431| v2431_84(void) = ^IndirectReadSideEffect[-1] : &:r2431_79, ~m2431_83 -# 2431| m2431_85(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2431_79 -# 2431| m2431_86(unknown) = Chi : total:m2431_83, partial:m2431_85 -# 2433| v2433_1(void) = NoOp : -# 2411| v2411_5(void) = ReturnVoid : -# 2411| v2411_6(void) = AliasedUse : ~m2431_83 -# 2411| v2411_7(void) = ExitFunction : +# 2431| r2431_75(glval>) = CopyValue : r2431_27 +# 2431| r2431_76(glval) = FunctionAddress[~vector] : +# 2431| v2431_77(void) = Call[~vector] : func:r2431_76, this:r2431_75 +# 2431| v2431_78(void) = ^IndirectReadSideEffect[-1] : &:r2431_75, m2431_33 +# 2431| m2431_79(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2431_75 +# 2433| v2433_1(void) = NoOp : +# 2411| v2411_5(void) = ReturnVoid : +# 2411| v2411_6(void) = AliasedUse : ~m2431_57 +# 2411| v2411_7(void) = ExitFunction : # 2411| Block 13 # 2411| v2411_8(void) = Unreached : 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 75e2cb4a67c..4bf7e254062 100644 --- a/cpp/ql/test/library-tests/ir/ir/raw_ir.expected +++ b/cpp/ql/test/library-tests/ir/ir/raw_ir.expected @@ -14289,68 +14289,67 @@ ir.cpp: # 2216| mu2216_7(ClassWithDestructor) = Store[#temp2216:45] : &:r2216_4, r2216_6 # 2216| r2216_8(ClassWithDestructor) = Load[#temp2216:45] : &:r2216_4, ~m? # 2216| v2216_9(void) = Call[vector] : func:r2216_3, this:r2216_1, 0:r2216_8 -# 2216| mu2216_10(unknown) = ^CallSideEffect : ~m? -# 2216| mu2216_11(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2216_1 -# 2216| r2216_12(glval) = CopyValue : r2216_4 -# 2216| r2216_13(glval) = FunctionAddress[~ClassWithDestructor] : -# 2216| v2216_14(void) = Call[~ClassWithDestructor] : func:r2216_13, this:r2216_12 -# 2216| mu2216_15(unknown) = ^CallSideEffect : ~m? -# 2216| v2216_16(void) = ^IndirectReadSideEffect[-1] : &:r2216_12, ~m? -# 2216| mu2216_17(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2216_12 -# 2216| r2216_18(glval &>) = VariableAddress[(__range)] : -# 2216| r2216_19(glval>) = VariableAddress[ys] : -# 2216| r2216_20(vector &) = CopyValue : r2216_19 -# 2216| mu2216_21(vector &) = Store[(__range)] : &:r2216_18, r2216_20 -# 2216| r2216_22(glval>) = VariableAddress[(__begin)] : -# 2216| r2216_23(glval &>) = VariableAddress[(__range)] : -# 2216| r2216_24(vector &) = Load[(__range)] : &:r2216_23, ~m? -#-----| r0_1(glval>) = CopyValue : r2216_24 +# 2216| mu2216_10(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2216_1 +# 2216| r2216_11(glval) = CopyValue : r2216_4 +# 2216| r2216_12(glval) = FunctionAddress[~ClassWithDestructor] : +# 2216| v2216_13(void) = Call[~ClassWithDestructor] : func:r2216_12, this:r2216_11 +# 2216| mu2216_14(unknown) = ^CallSideEffect : ~m? +# 2216| v2216_15(void) = ^IndirectReadSideEffect[-1] : &:r2216_11, ~m? +# 2216| mu2216_16(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2216_11 +# 2216| r2216_17(glval &>) = VariableAddress[(__range)] : +# 2216| r2216_18(glval>) = VariableAddress[ys] : +# 2216| r2216_19(vector &) = CopyValue : r2216_18 +# 2216| mu2216_20(vector &) = Store[(__range)] : &:r2216_17, r2216_19 +# 2216| r2216_21(glval>) = VariableAddress[(__begin)] : +# 2216| r2216_22(glval &>) = VariableAddress[(__range)] : +# 2216| r2216_23(vector &) = Load[(__range)] : &:r2216_22, ~m? +#-----| r0_1(glval>) = CopyValue : r2216_23 #-----| r0_2(glval>) = Convert : r0_1 -# 2216| r2216_25(glval) = FunctionAddress[begin] : -# 2216| r2216_26(iterator) = Call[begin] : func:r2216_25, this:r0_2 +# 2216| r2216_24(glval) = FunctionAddress[begin] : +# 2216| r2216_25(iterator) = Call[begin] : func:r2216_24, this:r0_2 #-----| v0_3(void) = ^IndirectReadSideEffect[-1] : &:r0_2, ~m? -# 2216| mu2216_27(iterator) = Store[(__begin)] : &:r2216_22, r2216_26 -# 2216| r2216_28(glval>) = VariableAddress[(__end)] : -# 2216| r2216_29(glval &>) = VariableAddress[(__range)] : -# 2216| r2216_30(vector &) = Load[(__range)] : &:r2216_29, ~m? -#-----| r0_4(glval>) = CopyValue : r2216_30 +# 2216| mu2216_26(iterator) = Store[(__begin)] : &:r2216_21, r2216_25 +# 2216| r2216_27(glval>) = VariableAddress[(__end)] : +# 2216| r2216_28(glval &>) = VariableAddress[(__range)] : +# 2216| r2216_29(vector &) = Load[(__range)] : &:r2216_28, ~m? +#-----| r0_4(glval>) = CopyValue : r2216_29 #-----| r0_5(glval>) = Convert : r0_4 -# 2216| r2216_31(glval) = FunctionAddress[end] : -# 2216| r2216_32(iterator) = Call[end] : func:r2216_31, this:r0_5 +# 2216| r2216_30(glval) = FunctionAddress[end] : +# 2216| r2216_31(iterator) = Call[end] : func:r2216_30, this:r0_5 #-----| v0_6(void) = ^IndirectReadSideEffect[-1] : &:r0_5, ~m? -# 2216| mu2216_33(iterator) = Store[(__end)] : &:r2216_28, r2216_32 +# 2216| mu2216_32(iterator) = Store[(__end)] : &:r2216_27, r2216_31 #-----| Goto -> Block 10 # 2216| Block 10 -# 2216| r2216_34(glval>) = VariableAddress[(__begin)] : -#-----| r0_7(glval>) = Convert : r2216_34 -# 2216| r2216_35(glval) = FunctionAddress[operator!=] : +# 2216| r2216_33(glval>) = VariableAddress[(__begin)] : +#-----| r0_7(glval>) = Convert : r2216_33 +# 2216| r2216_34(glval) = FunctionAddress[operator!=] : #-----| r0_8(glval>) = VariableAddress[#temp0:0] : #-----| mu0_9(iterator) = Uninitialized[#temp0:0] : &:r0_8 -# 2216| r2216_36(glval) = FunctionAddress[iterator] : -# 2216| r2216_37(glval>) = VariableAddress[(__end)] : -#-----| r0_10(glval>) = Convert : r2216_37 +# 2216| r2216_35(glval) = FunctionAddress[iterator] : +# 2216| r2216_36(glval>) = VariableAddress[(__end)] : +#-----| r0_10(glval>) = Convert : r2216_36 #-----| r0_11(iterator &) = CopyValue : r0_10 -# 2216| v2216_38(void) = Call[iterator] : func:r2216_36, this:r0_8, 0:r0_11 -# 2216| mu2216_39(unknown) = ^CallSideEffect : ~m? +# 2216| v2216_37(void) = Call[iterator] : func:r2216_35, this:r0_8, 0:r0_11 +# 2216| mu2216_38(unknown) = ^CallSideEffect : ~m? #-----| v0_12(void) = ^BufferReadSideEffect[0] : &:r0_11, ~m? -# 2216| mu2216_40(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 +# 2216| mu2216_39(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 #-----| r0_13(iterator) = Load[#temp0:0] : &:r0_8, ~m? -# 2216| r2216_41(bool) = Call[operator!=] : func:r2216_35, this:r0_7, 0:r0_13 +# 2216| r2216_40(bool) = Call[operator!=] : func:r2216_34, this:r0_7, 0:r0_13 #-----| v0_14(void) = ^IndirectReadSideEffect[-1] : &:r0_7, ~m? -# 2216| v2216_42(void) = ConditionalBranch : r2216_41 +# 2216| v2216_41(void) = ConditionalBranch : r2216_40 #-----| False -> Block 12 #-----| True -> Block 11 # 2216| Block 11 -# 2216| r2216_43(glval) = VariableAddress[y] : -# 2216| r2216_44(glval>) = VariableAddress[(__begin)] : -#-----| r0_15(glval>) = Convert : r2216_44 -# 2216| r2216_45(glval) = FunctionAddress[operator*] : -# 2216| r2216_46(ClassWithDestructor &) = Call[operator*] : func:r2216_45, this:r0_15 +# 2216| r2216_42(glval) = VariableAddress[y] : +# 2216| r2216_43(glval>) = VariableAddress[(__begin)] : +#-----| r0_15(glval>) = Convert : r2216_43 +# 2216| r2216_44(glval) = FunctionAddress[operator*] : +# 2216| r2216_45(ClassWithDestructor &) = Call[operator*] : func:r2216_44, this:r0_15 #-----| v0_16(void) = ^IndirectReadSideEffect[-1] : &:r0_15, ~m? -# 2216| r2216_47(ClassWithDestructor) = Load[?] : &:r2216_46, ~m? -# 2216| mu2216_48(ClassWithDestructor) = Store[y] : &:r2216_43, r2216_47 +# 2216| r2216_46(ClassWithDestructor) = Load[?] : &:r2216_45, ~m? +# 2216| mu2216_47(ClassWithDestructor) = Store[y] : &:r2216_42, r2216_46 # 2217| r2217_1(glval) = VariableAddress[y] : # 2217| r2217_2(glval) = FunctionAddress[set_x] : # 2217| r2217_3(char) = Constant[97] : @@ -14358,27 +14357,26 @@ ir.cpp: # 2217| mu2217_5(unknown) = ^CallSideEffect : ~m? # 2217| v2217_6(void) = ^IndirectReadSideEffect[-1] : &:r2217_1, ~m? # 2217| mu2217_7(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2217_1 -# 2216| r2216_49(glval>) = VariableAddress[(__begin)] : -# 2216| r2216_50(glval) = FunctionAddress[operator++] : -# 2216| r2216_51(iterator &) = Call[operator++] : func:r2216_50, this:r2216_49 -# 2216| v2216_52(void) = ^IndirectReadSideEffect[-1] : &:r2216_49, ~m? -# 2216| mu2216_53(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2216_49 -# 2216| r2216_54(glval) = VariableAddress[y] : -# 2216| r2216_55(glval) = FunctionAddress[~ClassWithDestructor] : -# 2216| v2216_56(void) = Call[~ClassWithDestructor] : func:r2216_55, this:r2216_54 -# 2216| mu2216_57(unknown) = ^CallSideEffect : ~m? -# 2216| v2216_58(void) = ^IndirectReadSideEffect[-1] : &:r2216_54, ~m? -# 2216| mu2216_59(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2216_54 -# 2216| r2216_60(glval>) = CopyValue : r2216_51 +# 2216| r2216_48(glval>) = VariableAddress[(__begin)] : +# 2216| r2216_49(glval) = FunctionAddress[operator++] : +# 2216| r2216_50(iterator &) = Call[operator++] : func:r2216_49, this:r2216_48 +# 2216| v2216_51(void) = ^IndirectReadSideEffect[-1] : &:r2216_48, ~m? +# 2216| mu2216_52(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2216_48 +# 2216| r2216_53(glval) = VariableAddress[y] : +# 2216| r2216_54(glval) = FunctionAddress[~ClassWithDestructor] : +# 2216| v2216_55(void) = Call[~ClassWithDestructor] : func:r2216_54, this:r2216_53 +# 2216| mu2216_56(unknown) = ^CallSideEffect : ~m? +# 2216| v2216_57(void) = ^IndirectReadSideEffect[-1] : &:r2216_53, ~m? +# 2216| mu2216_58(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2216_53 +# 2216| r2216_59(glval>) = CopyValue : r2216_50 #-----| Goto (back edge) -> Block 10 # 2216| Block 12 -# 2216| r2216_61(glval>) = VariableAddress[ys] : -# 2216| r2216_62(glval) = FunctionAddress[~vector] : -# 2216| v2216_63(void) = Call[~vector] : func:r2216_62, this:r2216_61 -# 2216| mu2216_64(unknown) = ^CallSideEffect : ~m? -# 2216| v2216_65(void) = ^IndirectReadSideEffect[-1] : &:r2216_61, ~m? -# 2216| mu2216_66(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2216_61 +# 2216| r2216_60(glval>) = VariableAddress[ys] : +# 2216| r2216_61(glval) = FunctionAddress[~vector] : +# 2216| v2216_62(void) = Call[~vector] : func:r2216_61, this:r2216_60 +# 2216| v2216_63(void) = ^IndirectReadSideEffect[-1] : &:r2216_60, ~m? +# 2216| mu2216_64(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2216_60 # 2219| r2219_1(glval>) = VariableAddress[ys] : # 2219| mu2219_2(vector) = Uninitialized[ys] : &:r2219_1 # 2219| r2219_3(glval) = FunctionAddress[vector] : @@ -14388,83 +14386,82 @@ ir.cpp: # 2219| mu2219_7(ClassWithDestructor) = Store[#temp2219:45] : &:r2219_4, r2219_6 # 2219| r2219_8(ClassWithDestructor) = Load[#temp2219:45] : &:r2219_4, ~m? # 2219| v2219_9(void) = Call[vector] : func:r2219_3, this:r2219_1, 0:r2219_8 -# 2219| mu2219_10(unknown) = ^CallSideEffect : ~m? -# 2219| mu2219_11(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2219_1 -# 2219| r2219_12(glval) = CopyValue : r2219_4 -# 2219| r2219_13(glval) = FunctionAddress[~ClassWithDestructor] : -# 2219| v2219_14(void) = Call[~ClassWithDestructor] : func:r2219_13, this:r2219_12 -# 2219| mu2219_15(unknown) = ^CallSideEffect : ~m? -# 2219| v2219_16(void) = ^IndirectReadSideEffect[-1] : &:r2219_12, ~m? -# 2219| mu2219_17(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2219_12 -# 2219| r2219_18(glval &>) = VariableAddress[(__range)] : -# 2219| r2219_19(glval>) = VariableAddress[ys] : -# 2219| r2219_20(vector &) = CopyValue : r2219_19 -# 2219| mu2219_21(vector &) = Store[(__range)] : &:r2219_18, r2219_20 -# 2219| r2219_22(glval>) = VariableAddress[(__begin)] : -# 2219| r2219_23(glval &>) = VariableAddress[(__range)] : -# 2219| r2219_24(vector &) = Load[(__range)] : &:r2219_23, ~m? -#-----| r0_17(glval>) = CopyValue : r2219_24 +# 2219| mu2219_10(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2219_1 +# 2219| r2219_11(glval) = CopyValue : r2219_4 +# 2219| r2219_12(glval) = FunctionAddress[~ClassWithDestructor] : +# 2219| v2219_13(void) = Call[~ClassWithDestructor] : func:r2219_12, this:r2219_11 +# 2219| mu2219_14(unknown) = ^CallSideEffect : ~m? +# 2219| v2219_15(void) = ^IndirectReadSideEffect[-1] : &:r2219_11, ~m? +# 2219| mu2219_16(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2219_11 +# 2219| r2219_17(glval &>) = VariableAddress[(__range)] : +# 2219| r2219_18(glval>) = VariableAddress[ys] : +# 2219| r2219_19(vector &) = CopyValue : r2219_18 +# 2219| mu2219_20(vector &) = Store[(__range)] : &:r2219_17, r2219_19 +# 2219| r2219_21(glval>) = VariableAddress[(__begin)] : +# 2219| r2219_22(glval &>) = VariableAddress[(__range)] : +# 2219| r2219_23(vector &) = Load[(__range)] : &:r2219_22, ~m? +#-----| r0_17(glval>) = CopyValue : r2219_23 #-----| r0_18(glval>) = Convert : r0_17 -# 2219| r2219_25(glval) = FunctionAddress[begin] : -# 2219| r2219_26(iterator) = Call[begin] : func:r2219_25, this:r0_18 +# 2219| r2219_24(glval) = FunctionAddress[begin] : +# 2219| r2219_25(iterator) = Call[begin] : func:r2219_24, this:r0_18 #-----| v0_19(void) = ^IndirectReadSideEffect[-1] : &:r0_18, ~m? -# 2219| mu2219_27(iterator) = Store[(__begin)] : &:r2219_22, r2219_26 -# 2219| r2219_28(glval>) = VariableAddress[(__end)] : -# 2219| r2219_29(glval &>) = VariableAddress[(__range)] : -# 2219| r2219_30(vector &) = Load[(__range)] : &:r2219_29, ~m? -#-----| r0_20(glval>) = CopyValue : r2219_30 +# 2219| mu2219_26(iterator) = Store[(__begin)] : &:r2219_21, r2219_25 +# 2219| r2219_27(glval>) = VariableAddress[(__end)] : +# 2219| r2219_28(glval &>) = VariableAddress[(__range)] : +# 2219| r2219_29(vector &) = Load[(__range)] : &:r2219_28, ~m? +#-----| r0_20(glval>) = CopyValue : r2219_29 #-----| r0_21(glval>) = Convert : r0_20 -# 2219| r2219_31(glval) = FunctionAddress[end] : -# 2219| r2219_32(iterator) = Call[end] : func:r2219_31, this:r0_21 +# 2219| r2219_30(glval) = FunctionAddress[end] : +# 2219| r2219_31(iterator) = Call[end] : func:r2219_30, this:r0_21 #-----| v0_22(void) = ^IndirectReadSideEffect[-1] : &:r0_21, ~m? -# 2219| mu2219_33(iterator) = Store[(__end)] : &:r2219_28, r2219_32 +# 2219| mu2219_32(iterator) = Store[(__end)] : &:r2219_27, r2219_31 #-----| Goto -> Block 13 # 2219| Block 13 -# 2219| r2219_34(glval>) = VariableAddress[(__begin)] : -#-----| r0_23(glval>) = Convert : r2219_34 -# 2219| r2219_35(glval) = FunctionAddress[operator!=] : +# 2219| r2219_33(glval>) = VariableAddress[(__begin)] : +#-----| r0_23(glval>) = Convert : r2219_33 +# 2219| r2219_34(glval) = FunctionAddress[operator!=] : #-----| r0_24(glval>) = VariableAddress[#temp0:0] : #-----| mu0_25(iterator) = Uninitialized[#temp0:0] : &:r0_24 -# 2219| r2219_36(glval) = FunctionAddress[iterator] : -# 2219| r2219_37(glval>) = VariableAddress[(__end)] : -#-----| r0_26(glval>) = Convert : r2219_37 +# 2219| r2219_35(glval) = FunctionAddress[iterator] : +# 2219| r2219_36(glval>) = VariableAddress[(__end)] : +#-----| r0_26(glval>) = Convert : r2219_36 #-----| r0_27(iterator &) = CopyValue : r0_26 -# 2219| v2219_38(void) = Call[iterator] : func:r2219_36, this:r0_24, 0:r0_27 -# 2219| mu2219_39(unknown) = ^CallSideEffect : ~m? +# 2219| v2219_37(void) = Call[iterator] : func:r2219_35, this:r0_24, 0:r0_27 +# 2219| mu2219_38(unknown) = ^CallSideEffect : ~m? #-----| v0_28(void) = ^BufferReadSideEffect[0] : &:r0_27, ~m? -# 2219| mu2219_40(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_24 +# 2219| mu2219_39(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_24 #-----| r0_29(iterator) = Load[#temp0:0] : &:r0_24, ~m? -# 2219| r2219_41(bool) = Call[operator!=] : func:r2219_35, this:r0_23, 0:r0_29 +# 2219| r2219_40(bool) = Call[operator!=] : func:r2219_34, this:r0_23, 0:r0_29 #-----| v0_30(void) = ^IndirectReadSideEffect[-1] : &:r0_23, ~m? -# 2219| v2219_42(void) = ConditionalBranch : r2219_41 +# 2219| v2219_41(void) = ConditionalBranch : r2219_40 #-----| False -> Block 17 #-----| True -> Block 15 # 2219| Block 14 -# 2219| r2219_43(glval>) = VariableAddress[(__begin)] : -# 2219| r2219_44(glval) = FunctionAddress[operator++] : -# 2219| r2219_45(iterator &) = Call[operator++] : func:r2219_44, this:r2219_43 -# 2219| v2219_46(void) = ^IndirectReadSideEffect[-1] : &:r2219_43, ~m? -# 2219| mu2219_47(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2219_43 -# 2219| r2219_48(glval) = VariableAddress[y] : -# 2219| r2219_49(glval) = FunctionAddress[~ClassWithDestructor] : -# 2219| v2219_50(void) = Call[~ClassWithDestructor] : func:r2219_49, this:r2219_48 -# 2219| mu2219_51(unknown) = ^CallSideEffect : ~m? -# 2219| v2219_52(void) = ^IndirectReadSideEffect[-1] : &:r2219_48, ~m? -# 2219| mu2219_53(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2219_48 -# 2219| r2219_54(glval>) = CopyValue : r2219_45 +# 2219| r2219_42(glval>) = VariableAddress[(__begin)] : +# 2219| r2219_43(glval) = FunctionAddress[operator++] : +# 2219| r2219_44(iterator &) = Call[operator++] : func:r2219_43, this:r2219_42 +# 2219| v2219_45(void) = ^IndirectReadSideEffect[-1] : &:r2219_42, ~m? +# 2219| mu2219_46(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2219_42 +# 2219| r2219_47(glval) = VariableAddress[y] : +# 2219| r2219_48(glval) = FunctionAddress[~ClassWithDestructor] : +# 2219| v2219_49(void) = Call[~ClassWithDestructor] : func:r2219_48, this:r2219_47 +# 2219| mu2219_50(unknown) = ^CallSideEffect : ~m? +# 2219| v2219_51(void) = ^IndirectReadSideEffect[-1] : &:r2219_47, ~m? +# 2219| mu2219_52(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2219_47 +# 2219| r2219_53(glval>) = CopyValue : r2219_44 #-----| Goto (back edge) -> Block 13 # 2219| Block 15 -# 2219| r2219_55(glval) = VariableAddress[y] : -# 2219| r2219_56(glval>) = VariableAddress[(__begin)] : -#-----| r0_31(glval>) = Convert : r2219_56 -# 2219| r2219_57(glval) = FunctionAddress[operator*] : -# 2219| r2219_58(ClassWithDestructor &) = Call[operator*] : func:r2219_57, this:r0_31 +# 2219| r2219_54(glval) = VariableAddress[y] : +# 2219| r2219_55(glval>) = VariableAddress[(__begin)] : +#-----| r0_31(glval>) = Convert : r2219_55 +# 2219| r2219_56(glval) = FunctionAddress[operator*] : +# 2219| r2219_57(ClassWithDestructor &) = Call[operator*] : func:r2219_56, this:r0_31 #-----| v0_32(void) = ^IndirectReadSideEffect[-1] : &:r0_31, ~m? -# 2219| r2219_59(ClassWithDestructor) = Load[?] : &:r2219_58, ~m? -# 2219| mu2219_60(ClassWithDestructor) = Store[y] : &:r2219_55, r2219_59 +# 2219| r2219_58(ClassWithDestructor) = Load[?] : &:r2219_57, ~m? +# 2219| mu2219_59(ClassWithDestructor) = Store[y] : &:r2219_54, r2219_58 # 2220| r2220_1(glval) = VariableAddress[y] : # 2220| r2220_2(glval) = FunctionAddress[set_x] : # 2220| r2220_3(char) = Constant[97] : @@ -14487,18 +14484,17 @@ ir.cpp: # 2222| Block 16 # 2222| v2222_1(void) = NoOp : -# 2219| r2219_61(glval) = VariableAddress[y] : -# 2219| r2219_62(glval) = FunctionAddress[~ClassWithDestructor] : -# 2219| v2219_63(void) = Call[~ClassWithDestructor] : func:r2219_62, this:r2219_61 -# 2219| mu2219_64(unknown) = ^CallSideEffect : ~m? -# 2219| v2219_65(void) = ^IndirectReadSideEffect[-1] : &:r2219_61, ~m? -# 2219| mu2219_66(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2219_61 -# 2219| r2219_67(glval>) = VariableAddress[ys] : -# 2219| r2219_68(glval) = FunctionAddress[~vector] : -# 2219| v2219_69(void) = Call[~vector] : func:r2219_68, this:r2219_67 -# 2219| mu2219_70(unknown) = ^CallSideEffect : ~m? -# 2219| v2219_71(void) = ^IndirectReadSideEffect[-1] : &:r2219_67, ~m? -# 2219| mu2219_72(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2219_67 +# 2219| r2219_60(glval) = VariableAddress[y] : +# 2219| r2219_61(glval) = FunctionAddress[~ClassWithDestructor] : +# 2219| v2219_62(void) = Call[~ClassWithDestructor] : func:r2219_61, this:r2219_60 +# 2219| mu2219_63(unknown) = ^CallSideEffect : ~m? +# 2219| v2219_64(void) = ^IndirectReadSideEffect[-1] : &:r2219_60, ~m? +# 2219| mu2219_65(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2219_60 +# 2219| r2219_66(glval>) = VariableAddress[ys] : +# 2219| r2219_67(glval) = FunctionAddress[~vector] : +# 2219| v2219_68(void) = Call[~vector] : func:r2219_67, this:r2219_66 +# 2219| v2219_69(void) = ^IndirectReadSideEffect[-1] : &:r2219_66, ~m? +# 2219| mu2219_70(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2219_66 # 2234| r2234_1(glval) = VariableAddress[x] : # 2234| r2234_2(glval) = FunctionAddress[~ClassWithDestructor] : # 2234| v2234_3(void) = Call[~ClassWithDestructor] : func:r2234_2, this:r2234_1 @@ -14508,82 +14504,80 @@ ir.cpp: #-----| Goto -> Block 1 # 2219| Block 17 -# 2219| r2219_73(glval>) = VariableAddress[ys] : -# 2219| r2219_74(glval) = FunctionAddress[~vector] : -# 2219| v2219_75(void) = Call[~vector] : func:r2219_74, this:r2219_73 -# 2219| mu2219_76(unknown) = ^CallSideEffect : ~m? -# 2219| v2219_77(void) = ^IndirectReadSideEffect[-1] : &:r2219_73, ~m? -# 2219| mu2219_78(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2219_73 -# 2225| r2225_1(glval>) = VariableAddress[ys] : -# 2225| mu2225_2(vector) = Uninitialized[ys] : &:r2225_1 -# 2225| r2225_3(glval) = FunctionAddress[vector] : -# 2225| r2225_4(int) = Constant[1] : -# 2225| v2225_5(void) = Call[vector] : func:r2225_3, this:r2225_1, 0:r2225_4 -# 2225| mu2225_6(unknown) = ^CallSideEffect : ~m? -# 2225| mu2225_7(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2225_1 -# 2225| r2225_8(glval &>) = VariableAddress[(__range)] : -# 2225| r2225_9(glval>) = VariableAddress[ys] : -# 2225| r2225_10(vector &) = CopyValue : r2225_9 -# 2225| mu2225_11(vector &) = Store[(__range)] : &:r2225_8, r2225_10 -# 2225| r2225_12(glval>) = VariableAddress[(__begin)] : -# 2225| r2225_13(glval &>) = VariableAddress[(__range)] : -# 2225| r2225_14(vector &) = Load[(__range)] : &:r2225_13, ~m? -#-----| r0_33(glval>) = CopyValue : r2225_14 -#-----| r0_34(glval>) = Convert : r0_33 -# 2225| r2225_15(glval) = FunctionAddress[begin] : -# 2225| r2225_16(iterator) = Call[begin] : func:r2225_15, this:r0_34 -#-----| v0_35(void) = ^IndirectReadSideEffect[-1] : &:r0_34, ~m? -# 2225| mu2225_17(iterator) = Store[(__begin)] : &:r2225_12, r2225_16 -# 2225| r2225_18(glval>) = VariableAddress[(__end)] : -# 2225| r2225_19(glval &>) = VariableAddress[(__range)] : -# 2225| r2225_20(vector &) = Load[(__range)] : &:r2225_19, ~m? -#-----| r0_36(glval>) = CopyValue : r2225_20 -#-----| r0_37(glval>) = Convert : r0_36 -# 2225| r2225_21(glval) = FunctionAddress[end] : -# 2225| r2225_22(iterator) = Call[end] : func:r2225_21, this:r0_37 -#-----| v0_38(void) = ^IndirectReadSideEffect[-1] : &:r0_37, ~m? -# 2225| mu2225_23(iterator) = Store[(__end)] : &:r2225_18, r2225_22 +# 2219| r2219_71(glval>) = VariableAddress[ys] : +# 2219| r2219_72(glval) = FunctionAddress[~vector] : +# 2219| v2219_73(void) = Call[~vector] : func:r2219_72, this:r2219_71 +# 2219| v2219_74(void) = ^IndirectReadSideEffect[-1] : &:r2219_71, ~m? +# 2219| mu2219_75(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2219_71 +# 2225| r2225_1(glval>) = VariableAddress[ys] : +# 2225| mu2225_2(vector) = Uninitialized[ys] : &:r2225_1 +# 2225| r2225_3(glval) = FunctionAddress[vector] : +# 2225| r2225_4(int) = Constant[1] : +# 2225| v2225_5(void) = Call[vector] : func:r2225_3, this:r2225_1, 0:r2225_4 +# 2225| mu2225_6(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2225_1 +# 2225| r2225_7(glval &>) = VariableAddress[(__range)] : +# 2225| r2225_8(glval>) = VariableAddress[ys] : +# 2225| r2225_9(vector &) = CopyValue : r2225_8 +# 2225| mu2225_10(vector &) = Store[(__range)] : &:r2225_7, r2225_9 +# 2225| r2225_11(glval>) = VariableAddress[(__begin)] : +# 2225| r2225_12(glval &>) = VariableAddress[(__range)] : +# 2225| r2225_13(vector &) = Load[(__range)] : &:r2225_12, ~m? +#-----| r0_33(glval>) = CopyValue : r2225_13 +#-----| r0_34(glval>) = Convert : r0_33 +# 2225| r2225_14(glval) = FunctionAddress[begin] : +# 2225| r2225_15(iterator) = Call[begin] : func:r2225_14, this:r0_34 +#-----| v0_35(void) = ^IndirectReadSideEffect[-1] : &:r0_34, ~m? +# 2225| mu2225_16(iterator) = Store[(__begin)] : &:r2225_11, r2225_15 +# 2225| r2225_17(glval>) = VariableAddress[(__end)] : +# 2225| r2225_18(glval &>) = VariableAddress[(__range)] : +# 2225| r2225_19(vector &) = Load[(__range)] : &:r2225_18, ~m? +#-----| r0_36(glval>) = CopyValue : r2225_19 +#-----| r0_37(glval>) = Convert : r0_36 +# 2225| r2225_20(glval) = FunctionAddress[end] : +# 2225| r2225_21(iterator) = Call[end] : func:r2225_20, this:r0_37 +#-----| v0_38(void) = ^IndirectReadSideEffect[-1] : &:r0_37, ~m? +# 2225| mu2225_22(iterator) = Store[(__end)] : &:r2225_17, r2225_21 #-----| Goto -> Block 18 # 2225| Block 18 -# 2225| r2225_24(glval>) = VariableAddress[(__begin)] : -#-----| r0_39(glval>) = Convert : r2225_24 -# 2225| r2225_25(glval) = FunctionAddress[operator!=] : +# 2225| r2225_23(glval>) = VariableAddress[(__begin)] : +#-----| r0_39(glval>) = Convert : r2225_23 +# 2225| r2225_24(glval) = FunctionAddress[operator!=] : #-----| r0_40(glval>) = VariableAddress[#temp0:0] : #-----| mu0_41(iterator) = Uninitialized[#temp0:0] : &:r0_40 -# 2225| r2225_26(glval) = FunctionAddress[iterator] : -# 2225| r2225_27(glval>) = VariableAddress[(__end)] : -#-----| r0_42(glval>) = Convert : r2225_27 +# 2225| r2225_25(glval) = FunctionAddress[iterator] : +# 2225| r2225_26(glval>) = VariableAddress[(__end)] : +#-----| r0_42(glval>) = Convert : r2225_26 #-----| r0_43(iterator &) = CopyValue : r0_42 -# 2225| v2225_28(void) = Call[iterator] : func:r2225_26, this:r0_40, 0:r0_43 -# 2225| mu2225_29(unknown) = ^CallSideEffect : ~m? +# 2225| v2225_27(void) = Call[iterator] : func:r2225_25, this:r0_40, 0:r0_43 +# 2225| mu2225_28(unknown) = ^CallSideEffect : ~m? #-----| v0_44(void) = ^BufferReadSideEffect[0] : &:r0_43, ~m? -# 2225| mu2225_30(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_40 +# 2225| mu2225_29(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_40 #-----| r0_45(iterator) = Load[#temp0:0] : &:r0_40, ~m? -# 2225| r2225_31(bool) = Call[operator!=] : func:r2225_25, this:r0_39, 0:r0_45 +# 2225| r2225_30(bool) = Call[operator!=] : func:r2225_24, this:r0_39, 0:r0_45 #-----| v0_46(void) = ^IndirectReadSideEffect[-1] : &:r0_39, ~m? -# 2225| v2225_32(void) = ConditionalBranch : r2225_31 +# 2225| v2225_31(void) = ConditionalBranch : r2225_30 #-----| False -> Block 22 #-----| True -> Block 20 # 2225| Block 19 -# 2225| r2225_33(glval>) = VariableAddress[(__begin)] : -# 2225| r2225_34(glval) = FunctionAddress[operator++] : -# 2225| r2225_35(iterator &) = Call[operator++] : func:r2225_34, this:r2225_33 -# 2225| v2225_36(void) = ^IndirectReadSideEffect[-1] : &:r2225_33, ~m? -# 2225| mu2225_37(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2225_33 -# 2225| r2225_38(glval>) = CopyValue : r2225_35 +# 2225| r2225_32(glval>) = VariableAddress[(__begin)] : +# 2225| r2225_33(glval) = FunctionAddress[operator++] : +# 2225| r2225_34(iterator &) = Call[operator++] : func:r2225_33, this:r2225_32 +# 2225| v2225_35(void) = ^IndirectReadSideEffect[-1] : &:r2225_32, ~m? +# 2225| mu2225_36(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2225_32 +# 2225| r2225_37(glval>) = CopyValue : r2225_34 #-----| Goto (back edge) -> Block 18 # 2225| Block 20 -# 2225| r2225_39(glval) = VariableAddress[y] : -# 2225| r2225_40(glval>) = VariableAddress[(__begin)] : -#-----| r0_47(glval>) = Convert : r2225_40 -# 2225| r2225_41(glval) = FunctionAddress[operator*] : -# 2225| r2225_42(int &) = Call[operator*] : func:r2225_41, this:r0_47 +# 2225| r2225_38(glval) = VariableAddress[y] : +# 2225| r2225_39(glval>) = VariableAddress[(__begin)] : +#-----| r0_47(glval>) = Convert : r2225_39 +# 2225| r2225_40(glval) = FunctionAddress[operator*] : +# 2225| r2225_41(int &) = Call[operator*] : func:r2225_40, this:r0_47 #-----| v0_48(void) = ^IndirectReadSideEffect[-1] : &:r0_47, ~m? -# 2225| r2225_43(int) = Load[?] : &:r2225_42, ~m? -# 2225| mu2225_44(int) = Store[y] : &:r2225_39, r2225_43 +# 2225| r2225_42(int) = Load[?] : &:r2225_41, ~m? +# 2225| mu2225_43(int) = Store[y] : &:r2225_38, r2225_42 # 2226| r2226_1(glval) = VariableAddress[y] : # 2226| r2226_2(int) = Load[y] : &:r2226_1, ~m? # 2226| r2226_3(int) = Constant[1] : @@ -14594,12 +14588,11 @@ ir.cpp: # 2227| Block 21 # 2227| v2227_1(void) = NoOp : -# 2225| r2225_45(glval>) = VariableAddress[ys] : -# 2225| r2225_46(glval) = FunctionAddress[~vector] : -# 2225| v2225_47(void) = Call[~vector] : func:r2225_46, this:r2225_45 -# 2225| mu2225_48(unknown) = ^CallSideEffect : ~m? -# 2225| v2225_49(void) = ^IndirectReadSideEffect[-1] : &:r2225_45, ~m? -# 2225| mu2225_50(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2225_45 +# 2225| r2225_44(glval>) = VariableAddress[ys] : +# 2225| r2225_45(glval) = FunctionAddress[~vector] : +# 2225| v2225_46(void) = Call[~vector] : func:r2225_45, this:r2225_44 +# 2225| v2225_47(void) = ^IndirectReadSideEffect[-1] : &:r2225_44, ~m? +# 2225| mu2225_48(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2225_44 # 2234| r2234_7(glval) = VariableAddress[x] : # 2234| r2234_8(glval) = FunctionAddress[~ClassWithDestructor] : # 2234| v2234_9(void) = Call[~ClassWithDestructor] : func:r2234_8, this:r2234_7 @@ -14609,12 +14602,11 @@ ir.cpp: #-----| Goto -> Block 1 # 2225| Block 22 -# 2225| r2225_51(glval>) = VariableAddress[ys] : -# 2225| r2225_52(glval) = FunctionAddress[~vector] : -# 2225| v2225_53(void) = Call[~vector] : func:r2225_52, this:r2225_51 -# 2225| mu2225_54(unknown) = ^CallSideEffect : ~m? -# 2225| v2225_55(void) = ^IndirectReadSideEffect[-1] : &:r2225_51, ~m? -# 2225| mu2225_56(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2225_51 +# 2225| r2225_49(glval>) = VariableAddress[ys] : +# 2225| r2225_50(glval) = FunctionAddress[~vector] : +# 2225| v2225_51(void) = Call[~vector] : func:r2225_50, this:r2225_49 +# 2225| v2225_52(void) = ^IndirectReadSideEffect[-1] : &:r2225_49, ~m? +# 2225| mu2225_53(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2225_49 # 2230| r2230_1(glval>) = VariableAddress[ys] : # 2230| mu2230_2(vector) = Uninitialized[ys] : &:r2230_1 # 2230| r2230_3(glval) = FunctionAddress[vector] : @@ -14624,68 +14616,67 @@ ir.cpp: # 2230| mu2230_7(ClassWithDestructor) = Store[#temp2230:45] : &:r2230_4, r2230_6 # 2230| r2230_8(ClassWithDestructor) = Load[#temp2230:45] : &:r2230_4, ~m? # 2230| v2230_9(void) = Call[vector] : func:r2230_3, this:r2230_1, 0:r2230_8 -# 2230| mu2230_10(unknown) = ^CallSideEffect : ~m? -# 2230| mu2230_11(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2230_1 -# 2230| r2230_12(glval) = CopyValue : r2230_4 -# 2230| r2230_13(glval) = FunctionAddress[~ClassWithDestructor] : -# 2230| v2230_14(void) = Call[~ClassWithDestructor] : func:r2230_13, this:r2230_12 -# 2230| mu2230_15(unknown) = ^CallSideEffect : ~m? -# 2230| v2230_16(void) = ^IndirectReadSideEffect[-1] : &:r2230_12, ~m? -# 2230| mu2230_17(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2230_12 -# 2230| r2230_18(glval &>) = VariableAddress[(__range)] : -# 2230| r2230_19(glval>) = VariableAddress[ys] : -# 2230| r2230_20(vector &) = CopyValue : r2230_19 -# 2230| mu2230_21(vector &) = Store[(__range)] : &:r2230_18, r2230_20 -# 2230| r2230_22(glval>) = VariableAddress[(__begin)] : -# 2230| r2230_23(glval &>) = VariableAddress[(__range)] : -# 2230| r2230_24(vector &) = Load[(__range)] : &:r2230_23, ~m? -#-----| r0_49(glval>) = CopyValue : r2230_24 +# 2230| mu2230_10(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2230_1 +# 2230| r2230_11(glval) = CopyValue : r2230_4 +# 2230| r2230_12(glval) = FunctionAddress[~ClassWithDestructor] : +# 2230| v2230_13(void) = Call[~ClassWithDestructor] : func:r2230_12, this:r2230_11 +# 2230| mu2230_14(unknown) = ^CallSideEffect : ~m? +# 2230| v2230_15(void) = ^IndirectReadSideEffect[-1] : &:r2230_11, ~m? +# 2230| mu2230_16(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2230_11 +# 2230| r2230_17(glval &>) = VariableAddress[(__range)] : +# 2230| r2230_18(glval>) = VariableAddress[ys] : +# 2230| r2230_19(vector &) = CopyValue : r2230_18 +# 2230| mu2230_20(vector &) = Store[(__range)] : &:r2230_17, r2230_19 +# 2230| r2230_21(glval>) = VariableAddress[(__begin)] : +# 2230| r2230_22(glval &>) = VariableAddress[(__range)] : +# 2230| r2230_23(vector &) = Load[(__range)] : &:r2230_22, ~m? +#-----| r0_49(glval>) = CopyValue : r2230_23 #-----| r0_50(glval>) = Convert : r0_49 -# 2230| r2230_25(glval) = FunctionAddress[begin] : -# 2230| r2230_26(iterator) = Call[begin] : func:r2230_25, this:r0_50 +# 2230| r2230_24(glval) = FunctionAddress[begin] : +# 2230| r2230_25(iterator) = Call[begin] : func:r2230_24, this:r0_50 #-----| v0_51(void) = ^IndirectReadSideEffect[-1] : &:r0_50, ~m? -# 2230| mu2230_27(iterator) = Store[(__begin)] : &:r2230_22, r2230_26 -# 2230| r2230_28(glval>) = VariableAddress[(__end)] : -# 2230| r2230_29(glval &>) = VariableAddress[(__range)] : -# 2230| r2230_30(vector &) = Load[(__range)] : &:r2230_29, ~m? -#-----| r0_52(glval>) = CopyValue : r2230_30 +# 2230| mu2230_26(iterator) = Store[(__begin)] : &:r2230_21, r2230_25 +# 2230| r2230_27(glval>) = VariableAddress[(__end)] : +# 2230| r2230_28(glval &>) = VariableAddress[(__range)] : +# 2230| r2230_29(vector &) = Load[(__range)] : &:r2230_28, ~m? +#-----| r0_52(glval>) = CopyValue : r2230_29 #-----| r0_53(glval>) = Convert : r0_52 -# 2230| r2230_31(glval) = FunctionAddress[end] : -# 2230| r2230_32(iterator) = Call[end] : func:r2230_31, this:r0_53 +# 2230| r2230_30(glval) = FunctionAddress[end] : +# 2230| r2230_31(iterator) = Call[end] : func:r2230_30, this:r0_53 #-----| v0_54(void) = ^IndirectReadSideEffect[-1] : &:r0_53, ~m? -# 2230| mu2230_33(iterator) = Store[(__end)] : &:r2230_28, r2230_32 +# 2230| mu2230_32(iterator) = Store[(__end)] : &:r2230_27, r2230_31 #-----| Goto -> Block 23 # 2230| Block 23 -# 2230| r2230_34(glval>) = VariableAddress[(__begin)] : -#-----| r0_55(glval>) = Convert : r2230_34 -# 2230| r2230_35(glval) = FunctionAddress[operator!=] : +# 2230| r2230_33(glval>) = VariableAddress[(__begin)] : +#-----| r0_55(glval>) = Convert : r2230_33 +# 2230| r2230_34(glval) = FunctionAddress[operator!=] : #-----| r0_56(glval>) = VariableAddress[#temp0:0] : #-----| mu0_57(iterator) = Uninitialized[#temp0:0] : &:r0_56 -# 2230| r2230_36(glval) = FunctionAddress[iterator] : -# 2230| r2230_37(glval>) = VariableAddress[(__end)] : -#-----| r0_58(glval>) = Convert : r2230_37 +# 2230| r2230_35(glval) = FunctionAddress[iterator] : +# 2230| r2230_36(glval>) = VariableAddress[(__end)] : +#-----| r0_58(glval>) = Convert : r2230_36 #-----| r0_59(iterator &) = CopyValue : r0_58 -# 2230| v2230_38(void) = Call[iterator] : func:r2230_36, this:r0_56, 0:r0_59 -# 2230| mu2230_39(unknown) = ^CallSideEffect : ~m? +# 2230| v2230_37(void) = Call[iterator] : func:r2230_35, this:r0_56, 0:r0_59 +# 2230| mu2230_38(unknown) = ^CallSideEffect : ~m? #-----| v0_60(void) = ^BufferReadSideEffect[0] : &:r0_59, ~m? -# 2230| mu2230_40(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_56 +# 2230| mu2230_39(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_56 #-----| r0_61(iterator) = Load[#temp0:0] : &:r0_56, ~m? -# 2230| r2230_41(bool) = Call[operator!=] : func:r2230_35, this:r0_55, 0:r0_61 +# 2230| r2230_40(bool) = Call[operator!=] : func:r2230_34, this:r0_55, 0:r0_61 #-----| v0_62(void) = ^IndirectReadSideEffect[-1] : &:r0_55, ~m? -# 2230| v2230_42(void) = ConditionalBranch : r2230_41 +# 2230| v2230_41(void) = ConditionalBranch : r2230_40 #-----| False -> Block 25 #-----| True -> Block 24 # 2230| Block 24 -# 2230| r2230_43(glval) = VariableAddress[y] : -# 2230| r2230_44(glval>) = VariableAddress[(__begin)] : -#-----| r0_63(glval>) = Convert : r2230_44 -# 2230| r2230_45(glval) = FunctionAddress[operator*] : -# 2230| r2230_46(ClassWithDestructor &) = Call[operator*] : func:r2230_45, this:r0_63 +# 2230| r2230_42(glval) = VariableAddress[y] : +# 2230| r2230_43(glval>) = VariableAddress[(__begin)] : +#-----| r0_63(glval>) = Convert : r2230_43 +# 2230| r2230_44(glval) = FunctionAddress[operator*] : +# 2230| r2230_45(ClassWithDestructor &) = Call[operator*] : func:r2230_44, this:r0_63 #-----| v0_64(void) = ^IndirectReadSideEffect[-1] : &:r0_63, ~m? -# 2230| r2230_47(ClassWithDestructor) = Load[?] : &:r2230_46, ~m? -# 2230| mu2230_48(ClassWithDestructor) = Store[y] : &:r2230_43, r2230_47 +# 2230| r2230_46(ClassWithDestructor) = Load[?] : &:r2230_45, ~m? +# 2230| mu2230_47(ClassWithDestructor) = Store[y] : &:r2230_42, r2230_46 # 2231| r2231_1(glval) = VariableAddress[z1] : # 2231| mu2231_2(ClassWithDestructor) = Uninitialized[z1] : &:r2231_1 # 2231| r2231_3(glval) = FunctionAddress[ClassWithDestructor] : @@ -14710,27 +14701,26 @@ ir.cpp: # 2233| mu2233_10(unknown) = ^CallSideEffect : ~m? # 2233| v2233_11(void) = ^IndirectReadSideEffect[-1] : &:r2233_7, ~m? # 2233| mu2233_12(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2233_7 -# 2230| r2230_49(glval>) = VariableAddress[(__begin)] : -# 2230| r2230_50(glval) = FunctionAddress[operator++] : -# 2230| r2230_51(iterator &) = Call[operator++] : func:r2230_50, this:r2230_49 -# 2230| v2230_52(void) = ^IndirectReadSideEffect[-1] : &:r2230_49, ~m? -# 2230| mu2230_53(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2230_49 -# 2230| r2230_54(glval) = VariableAddress[y] : -# 2230| r2230_55(glval) = FunctionAddress[~ClassWithDestructor] : -# 2230| v2230_56(void) = Call[~ClassWithDestructor] : func:r2230_55, this:r2230_54 -# 2230| mu2230_57(unknown) = ^CallSideEffect : ~m? -# 2230| v2230_58(void) = ^IndirectReadSideEffect[-1] : &:r2230_54, ~m? -# 2230| mu2230_59(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2230_54 -# 2230| r2230_60(glval>) = CopyValue : r2230_51 +# 2230| r2230_48(glval>) = VariableAddress[(__begin)] : +# 2230| r2230_49(glval) = FunctionAddress[operator++] : +# 2230| r2230_50(iterator &) = Call[operator++] : func:r2230_49, this:r2230_48 +# 2230| v2230_51(void) = ^IndirectReadSideEffect[-1] : &:r2230_48, ~m? +# 2230| mu2230_52(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2230_48 +# 2230| r2230_53(glval) = VariableAddress[y] : +# 2230| r2230_54(glval) = FunctionAddress[~ClassWithDestructor] : +# 2230| v2230_55(void) = Call[~ClassWithDestructor] : func:r2230_54, this:r2230_53 +# 2230| mu2230_56(unknown) = ^CallSideEffect : ~m? +# 2230| v2230_57(void) = ^IndirectReadSideEffect[-1] : &:r2230_53, ~m? +# 2230| mu2230_58(ClassWithDestructor) = ^IndirectMayWriteSideEffect[-1] : &:r2230_53 +# 2230| r2230_59(glval>) = CopyValue : r2230_50 #-----| Goto (back edge) -> Block 23 # 2230| Block 25 -# 2230| r2230_61(glval>) = VariableAddress[ys] : -# 2230| r2230_62(glval) = FunctionAddress[~vector] : -# 2230| v2230_63(void) = Call[~vector] : func:r2230_62, this:r2230_61 -# 2230| mu2230_64(unknown) = ^CallSideEffect : ~m? -# 2230| v2230_65(void) = ^IndirectReadSideEffect[-1] : &:r2230_61, ~m? -# 2230| mu2230_66(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2230_61 +# 2230| r2230_60(glval>) = VariableAddress[ys] : +# 2230| r2230_61(glval) = FunctionAddress[~vector] : +# 2230| v2230_62(void) = Call[~vector] : func:r2230_61, this:r2230_60 +# 2230| v2230_63(void) = ^IndirectReadSideEffect[-1] : &:r2230_60, ~m? +# 2230| mu2230_64(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2230_60 # 2234| v2234_13(void) = NoOp : # 2234| r2234_14(glval) = VariableAddress[x] : # 2234| r2234_15(glval) = FunctionAddress[~ClassWithDestructor] : @@ -15260,94 +15250,93 @@ ir.cpp: #-----| Goto (back edge) -> Block 1 # 2304| Block 3 -# 2304| r2304_24(glval) = VariableAddress[s] : -# 2304| r2304_25(glval) = FunctionAddress[~String] : -# 2304| v2304_26(void) = Call[~String] : func:r2304_25, this:r2304_24 -# 2304| mu2304_27(unknown) = ^CallSideEffect : ~m? -# 2304| v2304_28(void) = ^IndirectReadSideEffect[-1] : &:r2304_24, ~m? -# 2304| mu2304_29(String) = ^IndirectMayWriteSideEffect[-1] : &:r2304_24 -# 2308| r2308_1(glval &&>) = VariableAddress[(__range)] : -# 2308| r2308_2(glval>) = VariableAddress[#temp2308:20] : -# 2308| mu2308_3(vector) = Uninitialized[#temp2308:20] : &:r2308_2 -# 2308| r2308_4(glval) = FunctionAddress[vector] : -# 2308| r2308_5(glval) = VariableAddress[#temp2308:40] : -# 2308| mu2308_6(String) = Uninitialized[#temp2308:40] : &:r2308_5 -# 2308| r2308_7(glval) = FunctionAddress[String] : -# 2308| r2308_8(glval) = StringConstant["hello"] : -# 2308| r2308_9(char *) = Convert : r2308_8 -# 2308| v2308_10(void) = Call[String] : func:r2308_7, this:r2308_5, 0:r2308_9 -# 2308| mu2308_11(unknown) = ^CallSideEffect : ~m? -# 2308| v2308_12(void) = ^BufferReadSideEffect[0] : &:r2308_9, ~m? -# 2308| mu2308_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_5 -# 2308| r2308_14(String) = Load[#temp2308:40] : &:r2308_5, ~m? -# 2308| v2308_15(void) = Call[vector] : func:r2308_4, this:r2308_2, 0:r2308_14 -# 2308| mu2308_16(unknown) = ^CallSideEffect : ~m? -# 2308| mu2308_17(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2308_2 -# 2308| r2308_18(glval) = CopyValue : r2308_5 -# 2308| r2308_19(glval) = FunctionAddress[~String] : -# 2308| v2308_20(void) = Call[~String] : func:r2308_19, this:r2308_18 -# 2308| mu2308_21(unknown) = ^CallSideEffect : ~m? -# 2308| v2308_22(void) = ^IndirectReadSideEffect[-1] : &:r2308_18, ~m? -# 2308| mu2308_23(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_18 -# 2308| r2308_24(vector &) = CopyValue : r2308_2 -# 2308| mu2308_25(vector &&) = Store[(__range)] : &:r2308_1, r2308_24 -# 2308| r2308_26(glval>) = VariableAddress[(__begin)] : -# 2308| r2308_27(glval &&>) = VariableAddress[(__range)] : -# 2308| r2308_28(vector &&) = Load[(__range)] : &:r2308_27, ~m? -#-----| r0_1(glval>) = CopyValue : r2308_28 -#-----| r0_2(glval>) = Convert : r0_1 -# 2308| r2308_29(glval) = FunctionAddress[begin] : -# 2308| r2308_30(iterator) = Call[begin] : func:r2308_29, this:r0_2 -#-----| v0_3(void) = ^IndirectReadSideEffect[-1] : &:r0_2, ~m? -# 2308| mu2308_31(iterator) = Store[(__begin)] : &:r2308_26, r2308_30 -# 2308| r2308_32(glval>) = VariableAddress[(__end)] : -# 2308| r2308_33(glval &&>) = VariableAddress[(__range)] : -# 2308| r2308_34(vector &&) = Load[(__range)] : &:r2308_33, ~m? -#-----| r0_4(glval>) = CopyValue : r2308_34 -#-----| r0_5(glval>) = Convert : r0_4 -# 2308| r2308_35(glval) = FunctionAddress[end] : -# 2308| r2308_36(iterator) = Call[end] : func:r2308_35, this:r0_5 -#-----| v0_6(void) = ^IndirectReadSideEffect[-1] : &:r0_5, ~m? -# 2308| mu2308_37(iterator) = Store[(__end)] : &:r2308_32, r2308_36 +# 2304| r2304_24(glval) = VariableAddress[s] : +# 2304| r2304_25(glval) = FunctionAddress[~String] : +# 2304| v2304_26(void) = Call[~String] : func:r2304_25, this:r2304_24 +# 2304| mu2304_27(unknown) = ^CallSideEffect : ~m? +# 2304| v2304_28(void) = ^IndirectReadSideEffect[-1] : &:r2304_24, ~m? +# 2304| mu2304_29(String) = ^IndirectMayWriteSideEffect[-1] : &:r2304_24 +# 2308| r2308_1(glval &&>) = VariableAddress[(__range)] : +# 2308| r2308_2(glval>) = VariableAddress[#temp2308:20] : +# 2308| mu2308_3(vector) = Uninitialized[#temp2308:20] : &:r2308_2 +# 2308| r2308_4(glval) = FunctionAddress[vector] : +# 2308| r2308_5(glval) = VariableAddress[#temp2308:40] : +# 2308| mu2308_6(String) = Uninitialized[#temp2308:40] : &:r2308_5 +# 2308| r2308_7(glval) = FunctionAddress[String] : +# 2308| r2308_8(glval) = StringConstant["hello"] : +# 2308| r2308_9(char *) = Convert : r2308_8 +# 2308| v2308_10(void) = Call[String] : func:r2308_7, this:r2308_5, 0:r2308_9 +# 2308| mu2308_11(unknown) = ^CallSideEffect : ~m? +# 2308| v2308_12(void) = ^BufferReadSideEffect[0] : &:r2308_9, ~m? +# 2308| mu2308_13(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_5 +# 2308| r2308_14(String) = Load[#temp2308:40] : &:r2308_5, ~m? +# 2308| v2308_15(void) = Call[vector] : func:r2308_4, this:r2308_2, 0:r2308_14 +# 2308| mu2308_16(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2308_2 +# 2308| r2308_17(glval) = CopyValue : r2308_5 +# 2308| r2308_18(glval) = FunctionAddress[~String] : +# 2308| v2308_19(void) = Call[~String] : func:r2308_18, this:r2308_17 +# 2308| mu2308_20(unknown) = ^CallSideEffect : ~m? +# 2308| v2308_21(void) = ^IndirectReadSideEffect[-1] : &:r2308_17, ~m? +# 2308| mu2308_22(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_17 +# 2308| r2308_23(vector &) = CopyValue : r2308_2 +# 2308| mu2308_24(vector &&) = Store[(__range)] : &:r2308_1, r2308_23 +# 2308| r2308_25(glval>) = VariableAddress[(__begin)] : +# 2308| r2308_26(glval &&>) = VariableAddress[(__range)] : +# 2308| r2308_27(vector &&) = Load[(__range)] : &:r2308_26, ~m? +#-----| r0_1(glval>) = CopyValue : r2308_27 +#-----| r0_2(glval>) = Convert : r0_1 +# 2308| r2308_28(glval) = FunctionAddress[begin] : +# 2308| r2308_29(iterator) = Call[begin] : func:r2308_28, this:r0_2 +#-----| v0_3(void) = ^IndirectReadSideEffect[-1] : &:r0_2, ~m? +# 2308| mu2308_30(iterator) = Store[(__begin)] : &:r2308_25, r2308_29 +# 2308| r2308_31(glval>) = VariableAddress[(__end)] : +# 2308| r2308_32(glval &&>) = VariableAddress[(__range)] : +# 2308| r2308_33(vector &&) = Load[(__range)] : &:r2308_32, ~m? +#-----| r0_4(glval>) = CopyValue : r2308_33 +#-----| r0_5(glval>) = Convert : r0_4 +# 2308| r2308_34(glval) = FunctionAddress[end] : +# 2308| r2308_35(iterator) = Call[end] : func:r2308_34, this:r0_5 +#-----| v0_6(void) = ^IndirectReadSideEffect[-1] : &:r0_5, ~m? +# 2308| mu2308_36(iterator) = Store[(__end)] : &:r2308_31, r2308_35 #-----| Goto -> Block 4 # 2308| Block 4 -# 2308| r2308_38(glval>) = VariableAddress[(__begin)] : -#-----| r0_7(glval>) = Convert : r2308_38 -# 2308| r2308_39(glval) = FunctionAddress[operator!=] : +# 2308| r2308_37(glval>) = VariableAddress[(__begin)] : +#-----| r0_7(glval>) = Convert : r2308_37 +# 2308| r2308_38(glval) = FunctionAddress[operator!=] : #-----| r0_8(glval>) = VariableAddress[#temp0:0] : #-----| mu0_9(iterator) = Uninitialized[#temp0:0] : &:r0_8 -# 2308| r2308_40(glval) = FunctionAddress[iterator] : -# 2308| r2308_41(glval>) = VariableAddress[(__end)] : -#-----| r0_10(glval>) = Convert : r2308_41 +# 2308| r2308_39(glval) = FunctionAddress[iterator] : +# 2308| r2308_40(glval>) = VariableAddress[(__end)] : +#-----| r0_10(glval>) = Convert : r2308_40 #-----| r0_11(iterator &) = CopyValue : r0_10 -# 2308| v2308_42(void) = Call[iterator] : func:r2308_40, this:r0_8, 0:r0_11 -# 2308| mu2308_43(unknown) = ^CallSideEffect : ~m? +# 2308| v2308_41(void) = Call[iterator] : func:r2308_39, this:r0_8, 0:r0_11 +# 2308| mu2308_42(unknown) = ^CallSideEffect : ~m? #-----| v0_12(void) = ^BufferReadSideEffect[0] : &:r0_11, ~m? -# 2308| mu2308_44(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 +# 2308| mu2308_43(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 #-----| r0_13(iterator) = Load[#temp0:0] : &:r0_8, ~m? -# 2308| r2308_45(bool) = Call[operator!=] : func:r2308_39, this:r0_7, 0:r0_13 +# 2308| r2308_44(bool) = Call[operator!=] : func:r2308_38, this:r0_7, 0:r0_13 #-----| v0_14(void) = ^IndirectReadSideEffect[-1] : &:r0_7, ~m? -# 2308| v2308_46(void) = ConditionalBranch : r2308_45 +# 2308| v2308_45(void) = ConditionalBranch : r2308_44 #-----| False -> Block 6 #-----| True -> Block 5 # 2308| Block 5 -# 2308| r2308_47(glval) = VariableAddress[s] : -# 2308| mu2308_48(String) = Uninitialized[s] : &:r2308_47 -# 2308| r2308_49(glval) = FunctionAddress[String] : -# 2308| r2308_50(glval>) = VariableAddress[(__begin)] : -#-----| r0_15(glval>) = Convert : r2308_50 -# 2308| r2308_51(glval) = FunctionAddress[operator*] : -# 2308| r2308_52(String &) = Call[operator*] : func:r2308_51, this:r0_15 +# 2308| r2308_46(glval) = VariableAddress[s] : +# 2308| mu2308_47(String) = Uninitialized[s] : &:r2308_46 +# 2308| r2308_48(glval) = FunctionAddress[String] : +# 2308| r2308_49(glval>) = VariableAddress[(__begin)] : +#-----| r0_15(glval>) = Convert : r2308_49 +# 2308| r2308_50(glval) = FunctionAddress[operator*] : +# 2308| r2308_51(String &) = Call[operator*] : func:r2308_50, this:r0_15 #-----| v0_16(void) = ^IndirectReadSideEffect[-1] : &:r0_15, ~m? -# 2308| r2308_53(glval) = CopyValue : r2308_52 -# 2308| r2308_54(glval) = Convert : r2308_53 -# 2308| r2308_55(String &) = CopyValue : r2308_54 -# 2308| v2308_56(void) = Call[String] : func:r2308_49, this:r2308_47, 0:r2308_55 -# 2308| mu2308_57(unknown) = ^CallSideEffect : ~m? -# 2308| v2308_58(void) = ^BufferReadSideEffect[0] : &:r2308_55, ~m? -# 2308| mu2308_59(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_47 +# 2308| r2308_52(glval) = CopyValue : r2308_51 +# 2308| r2308_53(glval) = Convert : r2308_52 +# 2308| r2308_54(String &) = CopyValue : r2308_53 +# 2308| v2308_55(void) = Call[String] : func:r2308_48, this:r2308_46, 0:r2308_54 +# 2308| mu2308_56(unknown) = ^CallSideEffect : ~m? +# 2308| v2308_57(void) = ^BufferReadSideEffect[0] : &:r2308_54, ~m? +# 2308| mu2308_58(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_46 # 2309| r2309_1(glval) = VariableAddress[s2] : # 2309| mu2309_2(String) = Uninitialized[s2] : &:r2309_1 # 2309| r2309_3(glval) = FunctionAddress[String] : @@ -15360,45 +15349,44 @@ ir.cpp: # 2310| mu2310_4(unknown) = ^CallSideEffect : ~m? # 2310| v2310_5(void) = ^IndirectReadSideEffect[-1] : &:r2310_1, ~m? # 2310| mu2310_6(String) = ^IndirectMayWriteSideEffect[-1] : &:r2310_1 -# 2308| r2308_60(glval>) = VariableAddress[(__begin)] : -# 2308| r2308_61(glval) = FunctionAddress[operator++] : -# 2308| r2308_62(iterator &) = Call[operator++] : func:r2308_61, this:r2308_60 -# 2308| v2308_63(void) = ^IndirectReadSideEffect[-1] : &:r2308_60, ~m? -# 2308| mu2308_64(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2308_60 -# 2308| r2308_65(glval) = VariableAddress[s] : -# 2308| r2308_66(glval) = FunctionAddress[~String] : -# 2308| v2308_67(void) = Call[~String] : func:r2308_66, this:r2308_65 -# 2308| mu2308_68(unknown) = ^CallSideEffect : ~m? -# 2308| v2308_69(void) = ^IndirectReadSideEffect[-1] : &:r2308_65, ~m? -# 2308| mu2308_70(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_65 -# 2308| r2308_71(glval>) = CopyValue : r2308_62 +# 2308| r2308_59(glval>) = VariableAddress[(__begin)] : +# 2308| r2308_60(glval) = FunctionAddress[operator++] : +# 2308| r2308_61(iterator &) = Call[operator++] : func:r2308_60, this:r2308_59 +# 2308| v2308_62(void) = ^IndirectReadSideEffect[-1] : &:r2308_59, ~m? +# 2308| mu2308_63(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2308_59 +# 2308| r2308_64(glval) = VariableAddress[s] : +# 2308| r2308_65(glval) = FunctionAddress[~String] : +# 2308| v2308_66(void) = Call[~String] : func:r2308_65, this:r2308_64 +# 2308| mu2308_67(unknown) = ^CallSideEffect : ~m? +# 2308| v2308_68(void) = ^IndirectReadSideEffect[-1] : &:r2308_64, ~m? +# 2308| mu2308_69(String) = ^IndirectMayWriteSideEffect[-1] : &:r2308_64 +# 2308| r2308_70(glval>) = CopyValue : r2308_61 #-----| Goto (back edge) -> Block 4 # 2308| Block 6 -# 2308| r2308_72(glval>) = CopyValue : r2308_2 -# 2308| r2308_73(glval) = FunctionAddress[~vector] : -# 2308| v2308_74(void) = Call[~vector] : func:r2308_73, this:r2308_72 -# 2308| mu2308_75(unknown) = ^CallSideEffect : ~m? -# 2308| v2308_76(void) = ^IndirectReadSideEffect[-1] : &:r2308_72, ~m? -# 2308| mu2308_77(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2308_72 -# 2312| r2312_1(glval) = VariableAddress[s] : -# 2312| mu2312_2(String) = Uninitialized[s] : &:r2312_1 -# 2312| r2312_3(glval) = FunctionAddress[String] : -# 2312| r2312_4(glval) = StringConstant["hello"] : -# 2312| r2312_5(char *) = Convert : r2312_4 -# 2312| v2312_6(void) = Call[String] : func:r2312_3, this:r2312_1, 0:r2312_5 -# 2312| mu2312_7(unknown) = ^CallSideEffect : ~m? -# 2312| v2312_8(void) = ^BufferReadSideEffect[0] : &:r2312_5, ~m? -# 2312| mu2312_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r2312_1 -# 2312| r2312_10(glval) = VariableAddress[s2] : -# 2312| mu2312_11(String) = Uninitialized[s2] : &:r2312_10 -# 2312| r2312_12(glval) = FunctionAddress[String] : -# 2312| r2312_13(glval) = StringConstant["world"] : -# 2312| r2312_14(char *) = Convert : r2312_13 -# 2312| v2312_15(void) = Call[String] : func:r2312_12, this:r2312_10, 0:r2312_14 -# 2312| mu2312_16(unknown) = ^CallSideEffect : ~m? -# 2312| v2312_17(void) = ^BufferReadSideEffect[0] : &:r2312_14, ~m? -# 2312| mu2312_18(String) = ^IndirectMayWriteSideEffect[-1] : &:r2312_10 +# 2308| r2308_71(glval>) = CopyValue : r2308_2 +# 2308| r2308_72(glval) = FunctionAddress[~vector] : +# 2308| v2308_73(void) = Call[~vector] : func:r2308_72, this:r2308_71 +# 2308| v2308_74(void) = ^IndirectReadSideEffect[-1] : &:r2308_71, ~m? +# 2308| mu2308_75(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2308_71 +# 2312| r2312_1(glval) = VariableAddress[s] : +# 2312| mu2312_2(String) = Uninitialized[s] : &:r2312_1 +# 2312| r2312_3(glval) = FunctionAddress[String] : +# 2312| r2312_4(glval) = StringConstant["hello"] : +# 2312| r2312_5(char *) = Convert : r2312_4 +# 2312| v2312_6(void) = Call[String] : func:r2312_3, this:r2312_1, 0:r2312_5 +# 2312| mu2312_7(unknown) = ^CallSideEffect : ~m? +# 2312| v2312_8(void) = ^BufferReadSideEffect[0] : &:r2312_5, ~m? +# 2312| mu2312_9(String) = ^IndirectMayWriteSideEffect[-1] : &:r2312_1 +# 2312| r2312_10(glval) = VariableAddress[s2] : +# 2312| mu2312_11(String) = Uninitialized[s2] : &:r2312_10 +# 2312| r2312_12(glval) = FunctionAddress[String] : +# 2312| r2312_13(glval) = StringConstant["world"] : +# 2312| r2312_14(char *) = Convert : r2312_13 +# 2312| v2312_15(void) = Call[String] : func:r2312_12, this:r2312_10, 0:r2312_14 +# 2312| mu2312_16(unknown) = ^CallSideEffect : ~m? +# 2312| v2312_17(void) = ^BufferReadSideEffect[0] : &:r2312_14, ~m? +# 2312| mu2312_18(String) = ^IndirectMayWriteSideEffect[-1] : &:r2312_10 #-----| Goto -> Block 7 # 2312| Block 7 @@ -16038,60 +16026,59 @@ ir.cpp: # 2431| r2431_24(glval) = VariableAddress[x] : # 2431| r2431_25(char) = Load[x] : &:r2431_24, ~m? # 2431| v2431_26(void) = Call[vector] : func:r2431_23, this:r2431_21, 0:r2431_25 -# 2431| mu2431_27(unknown) = ^CallSideEffect : ~m? -# 2431| mu2431_28(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2431_21 -# 2431| r2431_29(vector &) = CopyValue : r2431_21 -# 2431| mu2431_30(vector &&) = Store[(__range)] : &:r2431_20, r2431_29 -# 2431| r2431_31(glval>) = VariableAddress[(__begin)] : -# 2431| r2431_32(glval &&>) = VariableAddress[(__range)] : -# 2431| r2431_33(vector &&) = Load[(__range)] : &:r2431_32, ~m? -#-----| r0_1(glval>) = CopyValue : r2431_33 +# 2431| mu2431_27(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2431_21 +# 2431| r2431_28(vector &) = CopyValue : r2431_21 +# 2431| mu2431_29(vector &&) = Store[(__range)] : &:r2431_20, r2431_28 +# 2431| r2431_30(glval>) = VariableAddress[(__begin)] : +# 2431| r2431_31(glval &&>) = VariableAddress[(__range)] : +# 2431| r2431_32(vector &&) = Load[(__range)] : &:r2431_31, ~m? +#-----| r0_1(glval>) = CopyValue : r2431_32 #-----| r0_2(glval>) = Convert : r0_1 -# 2431| r2431_34(glval) = FunctionAddress[begin] : -# 2431| r2431_35(iterator) = Call[begin] : func:r2431_34, this:r0_2 +# 2431| r2431_33(glval) = FunctionAddress[begin] : +# 2431| r2431_34(iterator) = Call[begin] : func:r2431_33, this:r0_2 #-----| v0_3(void) = ^IndirectReadSideEffect[-1] : &:r0_2, ~m? -# 2431| mu2431_36(iterator) = Store[(__begin)] : &:r2431_31, r2431_35 -# 2431| r2431_37(glval>) = VariableAddress[(__end)] : -# 2431| r2431_38(glval &&>) = VariableAddress[(__range)] : -# 2431| r2431_39(vector &&) = Load[(__range)] : &:r2431_38, ~m? -#-----| r0_4(glval>) = CopyValue : r2431_39 +# 2431| mu2431_35(iterator) = Store[(__begin)] : &:r2431_30, r2431_34 +# 2431| r2431_36(glval>) = VariableAddress[(__end)] : +# 2431| r2431_37(glval &&>) = VariableAddress[(__range)] : +# 2431| r2431_38(vector &&) = Load[(__range)] : &:r2431_37, ~m? +#-----| r0_4(glval>) = CopyValue : r2431_38 #-----| r0_5(glval>) = Convert : r0_4 -# 2431| r2431_40(glval) = FunctionAddress[end] : -# 2431| r2431_41(iterator) = Call[end] : func:r2431_40, this:r0_5 +# 2431| r2431_39(glval) = FunctionAddress[end] : +# 2431| r2431_40(iterator) = Call[end] : func:r2431_39, this:r0_5 #-----| v0_6(void) = ^IndirectReadSideEffect[-1] : &:r0_5, ~m? -# 2431| mu2431_42(iterator) = Store[(__end)] : &:r2431_37, r2431_41 +# 2431| mu2431_41(iterator) = Store[(__end)] : &:r2431_36, r2431_40 #-----| Goto -> Block 11 # 2431| Block 11 -# 2431| r2431_43(glval>) = VariableAddress[(__begin)] : -#-----| r0_7(glval>) = Convert : r2431_43 -# 2431| r2431_44(glval) = FunctionAddress[operator!=] : +# 2431| r2431_42(glval>) = VariableAddress[(__begin)] : +#-----| r0_7(glval>) = Convert : r2431_42 +# 2431| r2431_43(glval) = FunctionAddress[operator!=] : #-----| r0_8(glval>) = VariableAddress[#temp0:0] : #-----| mu0_9(iterator) = Uninitialized[#temp0:0] : &:r0_8 -# 2431| r2431_45(glval) = FunctionAddress[iterator] : -# 2431| r2431_46(glval>) = VariableAddress[(__end)] : -#-----| r0_10(glval>) = Convert : r2431_46 +# 2431| r2431_44(glval) = FunctionAddress[iterator] : +# 2431| r2431_45(glval>) = VariableAddress[(__end)] : +#-----| r0_10(glval>) = Convert : r2431_45 #-----| r0_11(iterator &) = CopyValue : r0_10 -# 2431| v2431_47(void) = Call[iterator] : func:r2431_45, this:r0_8, 0:r0_11 -# 2431| mu2431_48(unknown) = ^CallSideEffect : ~m? +# 2431| v2431_46(void) = Call[iterator] : func:r2431_44, this:r0_8, 0:r0_11 +# 2431| mu2431_47(unknown) = ^CallSideEffect : ~m? #-----| v0_12(void) = ^BufferReadSideEffect[0] : &:r0_11, ~m? -# 2431| mu2431_49(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 +# 2431| mu2431_48(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r0_8 #-----| r0_13(iterator) = Load[#temp0:0] : &:r0_8, ~m? -# 2431| r2431_50(bool) = Call[operator!=] : func:r2431_44, this:r0_7, 0:r0_13 +# 2431| r2431_49(bool) = Call[operator!=] : func:r2431_43, this:r0_7, 0:r0_13 #-----| v0_14(void) = ^IndirectReadSideEffect[-1] : &:r0_7, ~m? -# 2431| v2431_51(void) = ConditionalBranch : r2431_50 +# 2431| v2431_50(void) = ConditionalBranch : r2431_49 #-----| False -> Block 13 #-----| True -> Block 12 # 2431| Block 12 -# 2431| r2431_52(glval) = VariableAddress[y] : -# 2431| r2431_53(glval>) = VariableAddress[(__begin)] : -#-----| r0_15(glval>) = Convert : r2431_53 -# 2431| r2431_54(glval) = FunctionAddress[operator*] : -# 2431| r2431_55(char &) = Call[operator*] : func:r2431_54, this:r0_15 +# 2431| r2431_51(glval) = VariableAddress[y] : +# 2431| r2431_52(glval>) = VariableAddress[(__begin)] : +#-----| r0_15(glval>) = Convert : r2431_52 +# 2431| r2431_53(glval) = FunctionAddress[operator*] : +# 2431| r2431_54(char &) = Call[operator*] : func:r2431_53, this:r0_15 #-----| v0_16(void) = ^IndirectReadSideEffect[-1] : &:r0_15, ~m? -# 2431| r2431_56(char) = Load[?] : &:r2431_55, ~m? -# 2431| mu2431_57(char) = Store[y] : &:r2431_52, r2431_56 +# 2431| r2431_55(char) = Load[?] : &:r2431_54, ~m? +# 2431| mu2431_56(char) = Store[y] : &:r2431_51, r2431_55 # 2432| r2432_1(glval) = VariableAddress[x] : # 2432| r2432_2(char) = Load[x] : &:r2432_1, ~m? # 2432| r2432_3(int) = Convert : r2432_2 @@ -16101,25 +16088,24 @@ ir.cpp: # 2432| r2432_7(int) = Add : r2432_6, r2432_3 # 2432| r2432_8(char) = Convert : r2432_7 # 2432| mu2432_9(char) = Store[y] : &:r2432_4, r2432_8 -# 2431| r2431_58(glval>) = VariableAddress[(__begin)] : -# 2431| r2431_59(glval) = FunctionAddress[operator++] : -# 2431| r2431_60(iterator &) = Call[operator++] : func:r2431_59, this:r2431_58 -# 2431| v2431_61(void) = ^IndirectReadSideEffect[-1] : &:r2431_58, ~m? -# 2431| mu2431_62(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2431_58 -# 2431| r2431_63(glval>) = CopyValue : r2431_60 +# 2431| r2431_57(glval>) = VariableAddress[(__begin)] : +# 2431| r2431_58(glval) = FunctionAddress[operator++] : +# 2431| r2431_59(iterator &) = Call[operator++] : func:r2431_58, this:r2431_57 +# 2431| v2431_60(void) = ^IndirectReadSideEffect[-1] : &:r2431_57, ~m? +# 2431| mu2431_61(iterator) = ^IndirectMayWriteSideEffect[-1] : &:r2431_57 +# 2431| r2431_62(glval>) = CopyValue : r2431_59 #-----| Goto (back edge) -> Block 11 # 2431| Block 13 -# 2431| r2431_64(glval>) = CopyValue : r2431_21 -# 2431| r2431_65(glval) = FunctionAddress[~vector] : -# 2431| v2431_66(void) = Call[~vector] : func:r2431_65, this:r2431_64 -# 2431| mu2431_67(unknown) = ^CallSideEffect : ~m? -# 2431| v2431_68(void) = ^IndirectReadSideEffect[-1] : &:r2431_64, ~m? -# 2431| mu2431_69(vector) = ^IndirectMayWriteSideEffect[-1] : &:r2431_64 -# 2433| v2433_1(void) = NoOp : -# 2411| v2411_4(void) = ReturnVoid : -# 2411| v2411_5(void) = AliasedUse : ~m? -# 2411| v2411_6(void) = ExitFunction : +# 2431| r2431_63(glval>) = CopyValue : r2431_21 +# 2431| r2431_64(glval) = FunctionAddress[~vector] : +# 2431| v2431_65(void) = Call[~vector] : func:r2431_64, this:r2431_63 +# 2431| v2431_66(void) = ^IndirectReadSideEffect[-1] : &:r2431_63, ~m? +# 2431| mu2431_67(vector) = ^IndirectMustWriteSideEffect[-1] : &:r2431_63 +# 2433| v2433_1(void) = NoOp : +# 2411| v2411_4(void) = ReturnVoid : +# 2411| v2411_5(void) = AliasedUse : ~m? +# 2411| v2411_6(void) = ExitFunction : # 2435| void param_with_destructor_by_value(ClassWithDestructor) # 2435| Block 0