mirror of
https://github.com/github/codeql.git
synced 2026-04-30 03:05:15 +02:00
C++: generate Chi nodes on total IndirectMayWrites
This commit is contained in:
Robert Marsh
@@ -422,7 +422,11 @@ private predicate hasChiNode(Alias::VirtualVariable vvar, OldInstruction def) {
|
||||
defLocation.getVirtualVariable() = vvar and
|
||||
// If the definition totally (or exactly) overlaps the virtual variable, then there's no need for a `Chi`
|
||||
// instruction.
|
||||
Alias::getOverlap(defLocation, vvar) instanceof MayPartiallyOverlap
|
||||
(
|
||||
Alias::getOverlap(defLocation, vvar) instanceof MayPartiallyOverlap or
|
||||
def.getResultMemoryAccess() instanceof IndirectMayMemoryAccess or
|
||||
def.getResultMemoryAccess() instanceof BufferMayMemoryAccess
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
@@ -735,7 +739,8 @@ module DefUse {
|
||||
defLocation = Alias::getResultMemoryLocation(def) and
|
||||
block.getInstruction(index) = def and
|
||||
overlap = Alias::getOverlap(defLocation, useLocation) and
|
||||
if overlap instanceof MayPartiallyOverlap
|
||||
if
|
||||
overlap instanceof MayPartiallyOverlap
|
||||
then offset = (index * 2) + 1 // The use will be connected to the definition on the `Chi` instruction.
|
||||
else offset = index * 2 // The use will be connected to the definition on the original instruction.
|
||||
)
|
||||
|
||||
@@ -422,7 +422,11 @@ private predicate hasChiNode(Alias::VirtualVariable vvar, OldInstruction def) {
|
||||
defLocation.getVirtualVariable() = vvar and
|
||||
// If the definition totally (or exactly) overlaps the virtual variable, then there's no need for a `Chi`
|
||||
// instruction.
|
||||
Alias::getOverlap(defLocation, vvar) instanceof MayPartiallyOverlap
|
||||
(
|
||||
Alias::getOverlap(defLocation, vvar) instanceof MayPartiallyOverlap or
|
||||
def.getResultMemoryAccess() instanceof IndirectMayMemoryAccess or
|
||||
def.getResultMemoryAccess() instanceof BufferMayMemoryAccess
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
@@ -735,7 +739,8 @@ module DefUse {
|
||||
defLocation = Alias::getResultMemoryLocation(def) and
|
||||
block.getInstruction(index) = def and
|
||||
overlap = Alias::getOverlap(defLocation, useLocation) and
|
||||
if overlap instanceof MayPartiallyOverlap
|
||||
if
|
||||
overlap instanceof MayPartiallyOverlap
|
||||
then offset = (index * 2) + 1 // The use will be connected to the definition on the `Chi` instruction.
|
||||
else offset = index * 2 // The use will be connected to the definition on the original instruction.
|
||||
)
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import AliasAnalysis
|
||||
private import semmle.code.cpp.ir.implementation.MemoryAccessKind
|
||||
private import cpp
|
||||
private import semmle.code.cpp.ir.implementation.raw.IR
|
||||
private import semmle.code.cpp.ir.internal.IntegerConstant as Ints
|
||||
@@ -34,7 +35,11 @@ private predicate isVariableModeled(IRVariable var) {
|
||||
hasResultMemoryAccess(instr, var, type, bitOffset)
|
||||
|
|
||||
bitOffset = 0 and
|
||||
type = var.getType()
|
||||
type = var.getType() and
|
||||
not (
|
||||
instr.getResultMemoryAccess() instanceof IndirectMayMemoryAccess or
|
||||
instr.getResultMemoryAccess() instanceof BufferMayMemoryAccess
|
||||
)
|
||||
) and
|
||||
forall(MemoryOperand operand, Type type, IntValue bitOffset |
|
||||
hasOperandMemoryAccess(operand, var, type, bitOffset)
|
||||
|
||||
@@ -2712,37 +2712,40 @@ ir.cpp:
|
||||
# 615| mu0_1(unknown) = AliasedDefinition :
|
||||
# 615| mu0_2(unknown) = UnmodeledDefinition :
|
||||
# 616| r0_3(glval<String>) = VariableAddress[s1] :
|
||||
# 616| r0_4(glval<unknown>) = FunctionAddress[String] :
|
||||
# 616| v0_5(void) = Call : func:r0_4, this:r0_3
|
||||
# 616| mu0_6(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 616| mu0_7(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_3
|
||||
# 617| r0_8(glval<String>) = VariableAddress[s2] :
|
||||
# 617| r0_9(glval<unknown>) = FunctionAddress[String] :
|
||||
# 617| r0_10(glval<char[6]>) = StringConstant["hello"] :
|
||||
# 617| r0_11(char *) = Convert : r0_10
|
||||
# 617| v0_12(void) = Call : func:r0_9, this:r0_8, 0:r0_11
|
||||
# 617| mu0_13(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 617| mu0_14(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_8
|
||||
# 617| v0_15(void) = ^IndirectReadSideEffect[0] : &:r0_11, ~mu0_2
|
||||
# 617| mu0_16(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_11
|
||||
# 618| r0_17(glval<String>) = VariableAddress[s3] :
|
||||
# 618| r0_18(glval<unknown>) = FunctionAddress[ReturnObject] :
|
||||
# 618| r0_19(String) = Call : func:r0_18
|
||||
# 618| mu0_20(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 618| mu0_21(String) = Store : &:r0_17, r0_19
|
||||
# 619| r0_22(glval<String>) = VariableAddress[s4] :
|
||||
# 619| r0_23(glval<unknown>) = FunctionAddress[String] :
|
||||
# 619| r0_24(glval<char[5]>) = StringConstant["test"] :
|
||||
# 619| r0_25(char *) = Convert : r0_24
|
||||
# 619| v0_26(void) = Call : func:r0_23, this:r0_22, 0:r0_25
|
||||
# 619| mu0_27(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 619| mu0_28(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_22
|
||||
# 619| v0_29(void) = ^IndirectReadSideEffect[0] : &:r0_25, ~mu0_2
|
||||
# 619| mu0_30(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_25
|
||||
# 620| v0_31(void) = NoOp :
|
||||
# 615| v0_32(void) = ReturnVoid :
|
||||
# 615| v0_33(void) = UnmodeledUse : mu*
|
||||
# 615| v0_34(void) = ExitFunction :
|
||||
# 616| mu0_4(String) = Uninitialized[s1] : &:r0_3
|
||||
# 616| r0_5(glval<unknown>) = FunctionAddress[String] :
|
||||
# 616| v0_6(void) = Call : func:r0_5, this:r0_3
|
||||
# 616| mu0_7(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 616| mu0_8(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_3
|
||||
# 617| r0_9(glval<String>) = VariableAddress[s2] :
|
||||
# 617| mu0_10(String) = Uninitialized[s2] : &:r0_9
|
||||
# 617| r0_11(glval<unknown>) = FunctionAddress[String] :
|
||||
# 617| r0_12(glval<char[6]>) = StringConstant["hello"] :
|
||||
# 617| r0_13(char *) = Convert : r0_12
|
||||
# 617| v0_14(void) = Call : func:r0_11, this:r0_9, 0:r0_13
|
||||
# 617| mu0_15(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 617| mu0_16(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_9
|
||||
# 617| v0_17(void) = ^IndirectReadSideEffect[0] : &:r0_13, ~mu0_2
|
||||
# 617| mu0_18(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_13
|
||||
# 618| r0_19(glval<String>) = VariableAddress[s3] :
|
||||
# 618| r0_20(glval<unknown>) = FunctionAddress[ReturnObject] :
|
||||
# 618| r0_21(String) = Call : func:r0_20
|
||||
# 618| mu0_22(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 618| mu0_23(String) = Store : &:r0_19, r0_21
|
||||
# 619| r0_24(glval<String>) = VariableAddress[s4] :
|
||||
# 619| mu0_25(String) = Uninitialized[s4] : &:r0_24
|
||||
# 619| r0_26(glval<unknown>) = FunctionAddress[String] :
|
||||
# 619| r0_27(glval<char[5]>) = StringConstant["test"] :
|
||||
# 619| r0_28(char *) = Convert : r0_27
|
||||
# 619| v0_29(void) = Call : func:r0_26, this:r0_24, 0:r0_28
|
||||
# 619| mu0_30(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 619| mu0_31(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_24
|
||||
# 619| v0_32(void) = ^IndirectReadSideEffect[0] : &:r0_28, ~mu0_2
|
||||
# 619| mu0_33(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_28
|
||||
# 620| v0_34(void) = NoOp :
|
||||
# 615| v0_35(void) = ReturnVoid :
|
||||
# 615| v0_36(void) = UnmodeledUse : mu*
|
||||
# 615| v0_37(void) = ExitFunction :
|
||||
|
||||
# 622| void CallMethods(String&, String*, String)
|
||||
# 622| Block 0
|
||||
@@ -3640,261 +3643,264 @@ ir.cpp:
|
||||
# 799| mu0_1(unknown) = AliasedDefinition :
|
||||
# 799| mu0_2(unknown) = UnmodeledDefinition :
|
||||
# 800| r0_3(glval<Base>) = VariableAddress[b] :
|
||||
# 800| r0_4(glval<unknown>) = FunctionAddress[Base] :
|
||||
# 800| v0_5(void) = Call : func:r0_4, this:r0_3
|
||||
# 800| mu0_6(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 800| mu0_7(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_3
|
||||
# 801| r0_8(glval<Middle>) = VariableAddress[m] :
|
||||
# 801| r0_9(glval<unknown>) = FunctionAddress[Middle] :
|
||||
# 801| v0_10(void) = Call : func:r0_9, this:r0_8
|
||||
# 801| mu0_11(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 801| mu0_12(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_8
|
||||
# 802| r0_13(glval<Derived>) = VariableAddress[d] :
|
||||
# 802| r0_14(glval<unknown>) = FunctionAddress[Derived] :
|
||||
# 802| v0_15(void) = Call : func:r0_14, this:r0_13
|
||||
# 802| mu0_16(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 802| mu0_17(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r0_13
|
||||
# 804| r0_18(glval<Base *>) = VariableAddress[pb] :
|
||||
# 804| r0_19(glval<Base>) = VariableAddress[b] :
|
||||
# 804| mu0_20(Base *) = Store : &:r0_18, r0_19
|
||||
# 805| r0_21(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 805| r0_22(glval<Middle>) = VariableAddress[m] :
|
||||
# 805| mu0_23(Middle *) = Store : &:r0_21, r0_22
|
||||
# 806| r0_24(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 806| r0_25(glval<Derived>) = VariableAddress[d] :
|
||||
# 806| mu0_26(Derived *) = Store : &:r0_24, r0_25
|
||||
# 808| r0_27(glval<Base>) = VariableAddress[b] :
|
||||
# 808| r0_28(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 808| r0_29(glval<Middle>) = VariableAddress[m] :
|
||||
# 808| r0_30(glval<Base>) = ConvertToBase[Middle : Base] : r0_29
|
||||
# 808| r0_31(Base &) = Call : func:r0_28, this:r0_27, 0:r0_30
|
||||
# 808| mu0_32(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 808| v0_33(void) = ^IndirectReadSideEffect[-1] : &:r0_27, ~mu0_2
|
||||
# 808| v0_34(void) = ^IndirectReadSideEffect[0] : &:r0_30, ~mu0_2
|
||||
# 808| mu0_35(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_27
|
||||
# 808| mu0_36(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_30
|
||||
# 809| r0_37(glval<Base>) = VariableAddress[b] :
|
||||
# 809| r0_38(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 809| r0_39(glval<unknown>) = FunctionAddress[Base] :
|
||||
# 809| r0_40(glval<Middle>) = VariableAddress[m] :
|
||||
# 809| r0_41(glval<Base>) = ConvertToBase[Middle : Base] : r0_40
|
||||
# 809| v0_42(void) = Call : func:r0_39, 0:r0_41
|
||||
# 809| mu0_43(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 809| mu0_44(Base) = ^IndirectMayWriteSideEffect[-1] :
|
||||
# 809| v0_45(void) = ^IndirectReadSideEffect[0] : &:r0_41, ~mu0_2
|
||||
# 809| mu0_46(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_41
|
||||
# 809| r0_47(glval<Base>) = Convert : v0_42
|
||||
# 809| r0_48(Base &) = Call : func:r0_38, this:r0_37, 0:r0_47
|
||||
# 809| mu0_49(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 809| v0_50(void) = ^IndirectReadSideEffect[-1] : &:r0_37, ~mu0_2
|
||||
# 809| v0_51(void) = ^IndirectReadSideEffect[0] : &:r0_47, ~mu0_2
|
||||
# 809| mu0_52(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_37
|
||||
# 809| mu0_53(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_47
|
||||
# 810| r0_54(glval<Base>) = VariableAddress[b] :
|
||||
# 810| r0_55(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 810| r0_56(glval<unknown>) = FunctionAddress[Base] :
|
||||
# 810| r0_57(glval<Middle>) = VariableAddress[m] :
|
||||
# 810| r0_58(glval<Base>) = ConvertToBase[Middle : Base] : r0_57
|
||||
# 810| v0_59(void) = Call : func:r0_56, 0:r0_58
|
||||
# 810| mu0_60(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 810| mu0_61(Base) = ^IndirectMayWriteSideEffect[-1] :
|
||||
# 810| v0_62(void) = ^IndirectReadSideEffect[0] : &:r0_58, ~mu0_2
|
||||
# 810| mu0_63(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_58
|
||||
# 810| r0_64(glval<Base>) = Convert : v0_59
|
||||
# 810| r0_65(Base &) = Call : func:r0_55, this:r0_54, 0:r0_64
|
||||
# 810| mu0_66(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 810| v0_67(void) = ^IndirectReadSideEffect[-1] : &:r0_54, ~mu0_2
|
||||
# 810| v0_68(void) = ^IndirectReadSideEffect[0] : &:r0_64, ~mu0_2
|
||||
# 810| mu0_69(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_54
|
||||
# 810| mu0_70(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_64
|
||||
# 811| r0_71(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 811| r0_72(Middle *) = Load : &:r0_71, ~mu0_2
|
||||
# 811| r0_73(Base *) = ConvertToBase[Middle : Base] : r0_72
|
||||
# 811| r0_74(glval<Base *>) = VariableAddress[pb] :
|
||||
# 811| mu0_75(Base *) = Store : &:r0_74, r0_73
|
||||
# 812| r0_76(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 812| r0_77(Middle *) = Load : &:r0_76, ~mu0_2
|
||||
# 812| r0_78(Base *) = ConvertToBase[Middle : Base] : r0_77
|
||||
# 812| r0_79(glval<Base *>) = VariableAddress[pb] :
|
||||
# 812| mu0_80(Base *) = Store : &:r0_79, r0_78
|
||||
# 813| r0_81(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 813| r0_82(Middle *) = Load : &:r0_81, ~mu0_2
|
||||
# 813| r0_83(Base *) = ConvertToBase[Middle : Base] : r0_82
|
||||
# 813| r0_84(glval<Base *>) = VariableAddress[pb] :
|
||||
# 813| mu0_85(Base *) = Store : &:r0_84, r0_83
|
||||
# 814| r0_86(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 814| r0_87(Middle *) = Load : &:r0_86, ~mu0_2
|
||||
# 814| r0_88(Base *) = Convert : r0_87
|
||||
# 814| r0_89(glval<Base *>) = VariableAddress[pb] :
|
||||
# 814| mu0_90(Base *) = Store : &:r0_89, r0_88
|
||||
# 816| r0_91(glval<Middle>) = VariableAddress[m] :
|
||||
# 816| r0_92(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 816| r0_93(glval<Base>) = VariableAddress[b] :
|
||||
# 816| r0_94(glval<Middle>) = ConvertToDerived[Middle : Base] : r0_93
|
||||
# 816| r0_95(glval<Middle>) = Convert : r0_94
|
||||
# 816| r0_96(Middle &) = Call : func:r0_92, this:r0_91, 0:r0_95
|
||||
# 816| mu0_97(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 816| v0_98(void) = ^IndirectReadSideEffect[-1] : &:r0_91, ~mu0_2
|
||||
# 816| v0_99(void) = ^IndirectReadSideEffect[0] : &:r0_95, ~mu0_2
|
||||
# 816| mu0_100(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_91
|
||||
# 816| mu0_101(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_95
|
||||
# 817| r0_102(glval<Middle>) = VariableAddress[m] :
|
||||
# 817| r0_103(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 817| r0_104(glval<Base>) = VariableAddress[b] :
|
||||
# 817| r0_105(glval<Middle>) = ConvertToDerived[Middle : Base] : r0_104
|
||||
# 817| r0_106(glval<Middle>) = Convert : r0_105
|
||||
# 817| r0_107(Middle &) = Call : func:r0_103, this:r0_102, 0:r0_106
|
||||
# 817| mu0_108(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 817| v0_109(void) = ^IndirectReadSideEffect[-1] : &:r0_102, ~mu0_2
|
||||
# 817| v0_110(void) = ^IndirectReadSideEffect[0] : &:r0_106, ~mu0_2
|
||||
# 817| mu0_111(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_102
|
||||
# 817| mu0_112(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_106
|
||||
# 818| r0_113(glval<Base *>) = VariableAddress[pb] :
|
||||
# 818| r0_114(Base *) = Load : &:r0_113, ~mu0_2
|
||||
# 818| r0_115(Middle *) = ConvertToDerived[Middle : Base] : r0_114
|
||||
# 818| r0_116(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 818| mu0_117(Middle *) = Store : &:r0_116, r0_115
|
||||
# 819| r0_118(glval<Base *>) = VariableAddress[pb] :
|
||||
# 819| r0_119(Base *) = Load : &:r0_118, ~mu0_2
|
||||
# 819| r0_120(Middle *) = ConvertToDerived[Middle : Base] : r0_119
|
||||
# 819| r0_121(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 819| mu0_122(Middle *) = Store : &:r0_121, r0_120
|
||||
# 820| r0_123(glval<Base *>) = VariableAddress[pb] :
|
||||
# 820| r0_124(Base *) = Load : &:r0_123, ~mu0_2
|
||||
# 820| r0_125(Middle *) = Convert : r0_124
|
||||
# 820| r0_126(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 820| mu0_127(Middle *) = Store : &:r0_126, r0_125
|
||||
# 822| r0_128(glval<Base>) = VariableAddress[b] :
|
||||
# 822| r0_129(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 822| r0_130(glval<Derived>) = VariableAddress[d] :
|
||||
# 822| r0_131(glval<Middle>) = ConvertToBase[Derived : Middle] : r0_130
|
||||
# 822| r0_132(glval<Base>) = ConvertToBase[Middle : Base] : r0_131
|
||||
# 822| r0_133(Base &) = Call : func:r0_129, this:r0_128, 0:r0_132
|
||||
# 822| mu0_134(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 822| v0_135(void) = ^IndirectReadSideEffect[-1] : &:r0_128, ~mu0_2
|
||||
# 822| v0_136(void) = ^IndirectReadSideEffect[0] : &:r0_132, ~mu0_2
|
||||
# 822| mu0_137(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_128
|
||||
# 822| mu0_138(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_132
|
||||
# 823| r0_139(glval<Base>) = VariableAddress[b] :
|
||||
# 823| r0_140(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 823| r0_141(glval<unknown>) = FunctionAddress[Base] :
|
||||
# 823| r0_142(glval<Derived>) = VariableAddress[d] :
|
||||
# 823| r0_143(glval<Middle>) = ConvertToBase[Derived : Middle] : r0_142
|
||||
# 823| r0_144(glval<Base>) = ConvertToBase[Middle : Base] : r0_143
|
||||
# 823| v0_145(void) = Call : func:r0_141, 0:r0_144
|
||||
# 823| mu0_146(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 823| mu0_147(Base) = ^IndirectMayWriteSideEffect[-1] :
|
||||
# 823| v0_148(void) = ^IndirectReadSideEffect[0] : &:r0_144, ~mu0_2
|
||||
# 823| mu0_149(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_144
|
||||
# 823| r0_150(glval<Base>) = Convert : v0_145
|
||||
# 823| r0_151(Base &) = Call : func:r0_140, this:r0_139, 0:r0_150
|
||||
# 823| mu0_152(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 823| v0_153(void) = ^IndirectReadSideEffect[-1] : &:r0_139, ~mu0_2
|
||||
# 823| v0_154(void) = ^IndirectReadSideEffect[0] : &:r0_150, ~mu0_2
|
||||
# 823| mu0_155(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_139
|
||||
# 823| mu0_156(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_150
|
||||
# 824| r0_157(glval<Base>) = VariableAddress[b] :
|
||||
# 824| r0_158(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 824| r0_159(glval<unknown>) = FunctionAddress[Base] :
|
||||
# 824| r0_160(glval<Derived>) = VariableAddress[d] :
|
||||
# 824| r0_161(glval<Middle>) = ConvertToBase[Derived : Middle] : r0_160
|
||||
# 824| r0_162(glval<Base>) = ConvertToBase[Middle : Base] : r0_161
|
||||
# 824| v0_163(void) = Call : func:r0_159, 0:r0_162
|
||||
# 824| mu0_164(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 824| mu0_165(Base) = ^IndirectMayWriteSideEffect[-1] :
|
||||
# 824| v0_166(void) = ^IndirectReadSideEffect[0] : &:r0_162, ~mu0_2
|
||||
# 824| mu0_167(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_162
|
||||
# 824| r0_168(glval<Base>) = Convert : v0_163
|
||||
# 824| r0_169(Base &) = Call : func:r0_158, this:r0_157, 0:r0_168
|
||||
# 824| mu0_170(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 824| v0_171(void) = ^IndirectReadSideEffect[-1] : &:r0_157, ~mu0_2
|
||||
# 824| v0_172(void) = ^IndirectReadSideEffect[0] : &:r0_168, ~mu0_2
|
||||
# 824| mu0_173(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_157
|
||||
# 824| mu0_174(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_168
|
||||
# 825| r0_175(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 825| r0_176(Derived *) = Load : &:r0_175, ~mu0_2
|
||||
# 825| r0_177(Middle *) = ConvertToBase[Derived : Middle] : r0_176
|
||||
# 825| r0_178(Base *) = ConvertToBase[Middle : Base] : r0_177
|
||||
# 825| r0_179(glval<Base *>) = VariableAddress[pb] :
|
||||
# 825| mu0_180(Base *) = Store : &:r0_179, r0_178
|
||||
# 826| r0_181(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 826| r0_182(Derived *) = Load : &:r0_181, ~mu0_2
|
||||
# 826| r0_183(Middle *) = ConvertToBase[Derived : Middle] : r0_182
|
||||
# 826| r0_184(Base *) = ConvertToBase[Middle : Base] : r0_183
|
||||
# 826| r0_185(glval<Base *>) = VariableAddress[pb] :
|
||||
# 826| mu0_186(Base *) = Store : &:r0_185, r0_184
|
||||
# 827| r0_187(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 827| r0_188(Derived *) = Load : &:r0_187, ~mu0_2
|
||||
# 827| r0_189(Middle *) = ConvertToBase[Derived : Middle] : r0_188
|
||||
# 827| r0_190(Base *) = ConvertToBase[Middle : Base] : r0_189
|
||||
# 827| r0_191(glval<Base *>) = VariableAddress[pb] :
|
||||
# 827| mu0_192(Base *) = Store : &:r0_191, r0_190
|
||||
# 828| r0_193(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 828| r0_194(Derived *) = Load : &:r0_193, ~mu0_2
|
||||
# 828| r0_195(Base *) = Convert : r0_194
|
||||
# 828| r0_196(glval<Base *>) = VariableAddress[pb] :
|
||||
# 828| mu0_197(Base *) = Store : &:r0_196, r0_195
|
||||
# 830| r0_198(glval<Derived>) = VariableAddress[d] :
|
||||
# 830| r0_199(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 830| r0_200(glval<Base>) = VariableAddress[b] :
|
||||
# 830| r0_201(glval<Middle>) = ConvertToDerived[Middle : Base] : r0_200
|
||||
# 830| r0_202(glval<Derived>) = ConvertToDerived[Derived : Middle] : r0_201
|
||||
# 830| r0_203(glval<Derived>) = Convert : r0_202
|
||||
# 830| r0_204(Derived &) = Call : func:r0_199, this:r0_198, 0:r0_203
|
||||
# 830| mu0_205(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 830| v0_206(void) = ^IndirectReadSideEffect[-1] : &:r0_198, ~mu0_2
|
||||
# 830| v0_207(void) = ^IndirectReadSideEffect[0] : &:r0_203, ~mu0_2
|
||||
# 830| mu0_208(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r0_198
|
||||
# 830| mu0_209(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_203
|
||||
# 831| r0_210(glval<Derived>) = VariableAddress[d] :
|
||||
# 831| r0_211(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 831| r0_212(glval<Base>) = VariableAddress[b] :
|
||||
# 831| r0_213(glval<Middle>) = ConvertToDerived[Middle : Base] : r0_212
|
||||
# 831| r0_214(glval<Derived>) = ConvertToDerived[Derived : Middle] : r0_213
|
||||
# 831| r0_215(glval<Derived>) = Convert : r0_214
|
||||
# 831| r0_216(Derived &) = Call : func:r0_211, this:r0_210, 0:r0_215
|
||||
# 831| mu0_217(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 831| v0_218(void) = ^IndirectReadSideEffect[-1] : &:r0_210, ~mu0_2
|
||||
# 831| v0_219(void) = ^IndirectReadSideEffect[0] : &:r0_215, ~mu0_2
|
||||
# 831| mu0_220(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r0_210
|
||||
# 831| mu0_221(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_215
|
||||
# 832| r0_222(glval<Base *>) = VariableAddress[pb] :
|
||||
# 832| r0_223(Base *) = Load : &:r0_222, ~mu0_2
|
||||
# 832| r0_224(Middle *) = ConvertToDerived[Middle : Base] : r0_223
|
||||
# 832| r0_225(Derived *) = ConvertToDerived[Derived : Middle] : r0_224
|
||||
# 832| r0_226(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 832| mu0_227(Derived *) = Store : &:r0_226, r0_225
|
||||
# 833| r0_228(glval<Base *>) = VariableAddress[pb] :
|
||||
# 833| r0_229(Base *) = Load : &:r0_228, ~mu0_2
|
||||
# 833| r0_230(Middle *) = ConvertToDerived[Middle : Base] : r0_229
|
||||
# 833| r0_231(Derived *) = ConvertToDerived[Derived : Middle] : r0_230
|
||||
# 833| r0_232(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 833| mu0_233(Derived *) = Store : &:r0_232, r0_231
|
||||
# 834| r0_234(glval<Base *>) = VariableAddress[pb] :
|
||||
# 834| r0_235(Base *) = Load : &:r0_234, ~mu0_2
|
||||
# 834| r0_236(Derived *) = Convert : r0_235
|
||||
# 834| r0_237(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 834| mu0_238(Derived *) = Store : &:r0_237, r0_236
|
||||
# 836| r0_239(glval<MiddleVB1 *>) = VariableAddress[pmv] :
|
||||
# 836| r0_240(MiddleVB1 *) = Constant[0] :
|
||||
# 836| mu0_241(MiddleVB1 *) = Store : &:r0_239, r0_240
|
||||
# 837| r0_242(glval<DerivedVB *>) = VariableAddress[pdv] :
|
||||
# 837| r0_243(DerivedVB *) = Constant[0] :
|
||||
# 837| mu0_244(DerivedVB *) = Store : &:r0_242, r0_243
|
||||
# 838| r0_245(glval<MiddleVB1 *>) = VariableAddress[pmv] :
|
||||
# 838| r0_246(MiddleVB1 *) = Load : &:r0_245, ~mu0_2
|
||||
# 838| r0_247(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r0_246
|
||||
# 838| r0_248(glval<Base *>) = VariableAddress[pb] :
|
||||
# 838| mu0_249(Base *) = Store : &:r0_248, r0_247
|
||||
# 839| r0_250(glval<DerivedVB *>) = VariableAddress[pdv] :
|
||||
# 839| r0_251(DerivedVB *) = Load : &:r0_250, ~mu0_2
|
||||
# 839| r0_252(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r0_251
|
||||
# 839| r0_253(glval<Base *>) = VariableAddress[pb] :
|
||||
# 839| mu0_254(Base *) = Store : &:r0_253, r0_252
|
||||
# 840| v0_255(void) = NoOp :
|
||||
# 799| v0_256(void) = ReturnVoid :
|
||||
# 799| v0_257(void) = UnmodeledUse : mu*
|
||||
# 799| v0_258(void) = ExitFunction :
|
||||
# 800| mu0_4(Base) = Uninitialized[b] : &:r0_3
|
||||
# 800| r0_5(glval<unknown>) = FunctionAddress[Base] :
|
||||
# 800| v0_6(void) = Call : func:r0_5, this:r0_3
|
||||
# 800| mu0_7(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 800| mu0_8(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_3
|
||||
# 801| r0_9(glval<Middle>) = VariableAddress[m] :
|
||||
# 801| mu0_10(Middle) = Uninitialized[m] : &:r0_9
|
||||
# 801| r0_11(glval<unknown>) = FunctionAddress[Middle] :
|
||||
# 801| v0_12(void) = Call : func:r0_11, this:r0_9
|
||||
# 801| mu0_13(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 801| mu0_14(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_9
|
||||
# 802| r0_15(glval<Derived>) = VariableAddress[d] :
|
||||
# 802| mu0_16(Derived) = Uninitialized[d] : &:r0_15
|
||||
# 802| r0_17(glval<unknown>) = FunctionAddress[Derived] :
|
||||
# 802| v0_18(void) = Call : func:r0_17, this:r0_15
|
||||
# 802| mu0_19(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 802| mu0_20(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r0_15
|
||||
# 804| r0_21(glval<Base *>) = VariableAddress[pb] :
|
||||
# 804| r0_22(glval<Base>) = VariableAddress[b] :
|
||||
# 804| mu0_23(Base *) = Store : &:r0_21, r0_22
|
||||
# 805| r0_24(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 805| r0_25(glval<Middle>) = VariableAddress[m] :
|
||||
# 805| mu0_26(Middle *) = Store : &:r0_24, r0_25
|
||||
# 806| r0_27(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 806| r0_28(glval<Derived>) = VariableAddress[d] :
|
||||
# 806| mu0_29(Derived *) = Store : &:r0_27, r0_28
|
||||
# 808| r0_30(glval<Base>) = VariableAddress[b] :
|
||||
# 808| r0_31(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 808| r0_32(glval<Middle>) = VariableAddress[m] :
|
||||
# 808| r0_33(glval<Base>) = ConvertToBase[Middle : Base] : r0_32
|
||||
# 808| r0_34(Base &) = Call : func:r0_31, this:r0_30, 0:r0_33
|
||||
# 808| mu0_35(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 808| v0_36(void) = ^IndirectReadSideEffect[-1] : &:r0_30, ~mu0_2
|
||||
# 808| v0_37(void) = ^IndirectReadSideEffect[0] : &:r0_33, ~mu0_2
|
||||
# 808| mu0_38(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_30
|
||||
# 808| mu0_39(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_33
|
||||
# 809| r0_40(glval<Base>) = VariableAddress[b] :
|
||||
# 809| r0_41(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 809| r0_42(glval<unknown>) = FunctionAddress[Base] :
|
||||
# 809| r0_43(glval<Middle>) = VariableAddress[m] :
|
||||
# 809| r0_44(glval<Base>) = ConvertToBase[Middle : Base] : r0_43
|
||||
# 809| v0_45(void) = Call : func:r0_42, 0:r0_44
|
||||
# 809| mu0_46(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 809| mu0_47(Base) = ^IndirectMayWriteSideEffect[-1] :
|
||||
# 809| v0_48(void) = ^IndirectReadSideEffect[0] : &:r0_44, ~mu0_2
|
||||
# 809| mu0_49(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_44
|
||||
# 809| r0_50(glval<Base>) = Convert : v0_45
|
||||
# 809| r0_51(Base &) = Call : func:r0_41, this:r0_40, 0:r0_50
|
||||
# 809| mu0_52(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 809| v0_53(void) = ^IndirectReadSideEffect[-1] : &:r0_40, ~mu0_2
|
||||
# 809| v0_54(void) = ^IndirectReadSideEffect[0] : &:r0_50, ~mu0_2
|
||||
# 809| mu0_55(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_40
|
||||
# 809| mu0_56(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_50
|
||||
# 810| r0_57(glval<Base>) = VariableAddress[b] :
|
||||
# 810| r0_58(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 810| r0_59(glval<unknown>) = FunctionAddress[Base] :
|
||||
# 810| r0_60(glval<Middle>) = VariableAddress[m] :
|
||||
# 810| r0_61(glval<Base>) = ConvertToBase[Middle : Base] : r0_60
|
||||
# 810| v0_62(void) = Call : func:r0_59, 0:r0_61
|
||||
# 810| mu0_63(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 810| mu0_64(Base) = ^IndirectMayWriteSideEffect[-1] :
|
||||
# 810| v0_65(void) = ^IndirectReadSideEffect[0] : &:r0_61, ~mu0_2
|
||||
# 810| mu0_66(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_61
|
||||
# 810| r0_67(glval<Base>) = Convert : v0_62
|
||||
# 810| r0_68(Base &) = Call : func:r0_58, this:r0_57, 0:r0_67
|
||||
# 810| mu0_69(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 810| v0_70(void) = ^IndirectReadSideEffect[-1] : &:r0_57, ~mu0_2
|
||||
# 810| v0_71(void) = ^IndirectReadSideEffect[0] : &:r0_67, ~mu0_2
|
||||
# 810| mu0_72(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_57
|
||||
# 810| mu0_73(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_67
|
||||
# 811| r0_74(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 811| r0_75(Middle *) = Load : &:r0_74, ~mu0_2
|
||||
# 811| r0_76(Base *) = ConvertToBase[Middle : Base] : r0_75
|
||||
# 811| r0_77(glval<Base *>) = VariableAddress[pb] :
|
||||
# 811| mu0_78(Base *) = Store : &:r0_77, r0_76
|
||||
# 812| r0_79(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 812| r0_80(Middle *) = Load : &:r0_79, ~mu0_2
|
||||
# 812| r0_81(Base *) = ConvertToBase[Middle : Base] : r0_80
|
||||
# 812| r0_82(glval<Base *>) = VariableAddress[pb] :
|
||||
# 812| mu0_83(Base *) = Store : &:r0_82, r0_81
|
||||
# 813| r0_84(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 813| r0_85(Middle *) = Load : &:r0_84, ~mu0_2
|
||||
# 813| r0_86(Base *) = ConvertToBase[Middle : Base] : r0_85
|
||||
# 813| r0_87(glval<Base *>) = VariableAddress[pb] :
|
||||
# 813| mu0_88(Base *) = Store : &:r0_87, r0_86
|
||||
# 814| r0_89(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 814| r0_90(Middle *) = Load : &:r0_89, ~mu0_2
|
||||
# 814| r0_91(Base *) = Convert : r0_90
|
||||
# 814| r0_92(glval<Base *>) = VariableAddress[pb] :
|
||||
# 814| mu0_93(Base *) = Store : &:r0_92, r0_91
|
||||
# 816| r0_94(glval<Middle>) = VariableAddress[m] :
|
||||
# 816| r0_95(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 816| r0_96(glval<Base>) = VariableAddress[b] :
|
||||
# 816| r0_97(glval<Middle>) = ConvertToDerived[Middle : Base] : r0_96
|
||||
# 816| r0_98(glval<Middle>) = Convert : r0_97
|
||||
# 816| r0_99(Middle &) = Call : func:r0_95, this:r0_94, 0:r0_98
|
||||
# 816| mu0_100(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 816| v0_101(void) = ^IndirectReadSideEffect[-1] : &:r0_94, ~mu0_2
|
||||
# 816| v0_102(void) = ^IndirectReadSideEffect[0] : &:r0_98, ~mu0_2
|
||||
# 816| mu0_103(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_94
|
||||
# 816| mu0_104(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_98
|
||||
# 817| r0_105(glval<Middle>) = VariableAddress[m] :
|
||||
# 817| r0_106(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 817| r0_107(glval<Base>) = VariableAddress[b] :
|
||||
# 817| r0_108(glval<Middle>) = ConvertToDerived[Middle : Base] : r0_107
|
||||
# 817| r0_109(glval<Middle>) = Convert : r0_108
|
||||
# 817| r0_110(Middle &) = Call : func:r0_106, this:r0_105, 0:r0_109
|
||||
# 817| mu0_111(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 817| v0_112(void) = ^IndirectReadSideEffect[-1] : &:r0_105, ~mu0_2
|
||||
# 817| v0_113(void) = ^IndirectReadSideEffect[0] : &:r0_109, ~mu0_2
|
||||
# 817| mu0_114(Middle) = ^IndirectMayWriteSideEffect[-1] : &:r0_105
|
||||
# 817| mu0_115(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_109
|
||||
# 818| r0_116(glval<Base *>) = VariableAddress[pb] :
|
||||
# 818| r0_117(Base *) = Load : &:r0_116, ~mu0_2
|
||||
# 818| r0_118(Middle *) = ConvertToDerived[Middle : Base] : r0_117
|
||||
# 818| r0_119(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 818| mu0_120(Middle *) = Store : &:r0_119, r0_118
|
||||
# 819| r0_121(glval<Base *>) = VariableAddress[pb] :
|
||||
# 819| r0_122(Base *) = Load : &:r0_121, ~mu0_2
|
||||
# 819| r0_123(Middle *) = ConvertToDerived[Middle : Base] : r0_122
|
||||
# 819| r0_124(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 819| mu0_125(Middle *) = Store : &:r0_124, r0_123
|
||||
# 820| r0_126(glval<Base *>) = VariableAddress[pb] :
|
||||
# 820| r0_127(Base *) = Load : &:r0_126, ~mu0_2
|
||||
# 820| r0_128(Middle *) = Convert : r0_127
|
||||
# 820| r0_129(glval<Middle *>) = VariableAddress[pm] :
|
||||
# 820| mu0_130(Middle *) = Store : &:r0_129, r0_128
|
||||
# 822| r0_131(glval<Base>) = VariableAddress[b] :
|
||||
# 822| r0_132(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 822| r0_133(glval<Derived>) = VariableAddress[d] :
|
||||
# 822| r0_134(glval<Middle>) = ConvertToBase[Derived : Middle] : r0_133
|
||||
# 822| r0_135(glval<Base>) = ConvertToBase[Middle : Base] : r0_134
|
||||
# 822| r0_136(Base &) = Call : func:r0_132, this:r0_131, 0:r0_135
|
||||
# 822| mu0_137(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 822| v0_138(void) = ^IndirectReadSideEffect[-1] : &:r0_131, ~mu0_2
|
||||
# 822| v0_139(void) = ^IndirectReadSideEffect[0] : &:r0_135, ~mu0_2
|
||||
# 822| mu0_140(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_131
|
||||
# 822| mu0_141(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_135
|
||||
# 823| r0_142(glval<Base>) = VariableAddress[b] :
|
||||
# 823| r0_143(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 823| r0_144(glval<unknown>) = FunctionAddress[Base] :
|
||||
# 823| r0_145(glval<Derived>) = VariableAddress[d] :
|
||||
# 823| r0_146(glval<Middle>) = ConvertToBase[Derived : Middle] : r0_145
|
||||
# 823| r0_147(glval<Base>) = ConvertToBase[Middle : Base] : r0_146
|
||||
# 823| v0_148(void) = Call : func:r0_144, 0:r0_147
|
||||
# 823| mu0_149(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 823| mu0_150(Base) = ^IndirectMayWriteSideEffect[-1] :
|
||||
# 823| v0_151(void) = ^IndirectReadSideEffect[0] : &:r0_147, ~mu0_2
|
||||
# 823| mu0_152(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_147
|
||||
# 823| r0_153(glval<Base>) = Convert : v0_148
|
||||
# 823| r0_154(Base &) = Call : func:r0_143, this:r0_142, 0:r0_153
|
||||
# 823| mu0_155(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 823| v0_156(void) = ^IndirectReadSideEffect[-1] : &:r0_142, ~mu0_2
|
||||
# 823| v0_157(void) = ^IndirectReadSideEffect[0] : &:r0_153, ~mu0_2
|
||||
# 823| mu0_158(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_142
|
||||
# 823| mu0_159(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_153
|
||||
# 824| r0_160(glval<Base>) = VariableAddress[b] :
|
||||
# 824| r0_161(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 824| r0_162(glval<unknown>) = FunctionAddress[Base] :
|
||||
# 824| r0_163(glval<Derived>) = VariableAddress[d] :
|
||||
# 824| r0_164(glval<Middle>) = ConvertToBase[Derived : Middle] : r0_163
|
||||
# 824| r0_165(glval<Base>) = ConvertToBase[Middle : Base] : r0_164
|
||||
# 824| v0_166(void) = Call : func:r0_162, 0:r0_165
|
||||
# 824| mu0_167(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 824| mu0_168(Base) = ^IndirectMayWriteSideEffect[-1] :
|
||||
# 824| v0_169(void) = ^IndirectReadSideEffect[0] : &:r0_165, ~mu0_2
|
||||
# 824| mu0_170(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_165
|
||||
# 824| r0_171(glval<Base>) = Convert : v0_166
|
||||
# 824| r0_172(Base &) = Call : func:r0_161, this:r0_160, 0:r0_171
|
||||
# 824| mu0_173(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 824| v0_174(void) = ^IndirectReadSideEffect[-1] : &:r0_160, ~mu0_2
|
||||
# 824| v0_175(void) = ^IndirectReadSideEffect[0] : &:r0_171, ~mu0_2
|
||||
# 824| mu0_176(Base) = ^IndirectMayWriteSideEffect[-1] : &:r0_160
|
||||
# 824| mu0_177(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_171
|
||||
# 825| r0_178(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 825| r0_179(Derived *) = Load : &:r0_178, ~mu0_2
|
||||
# 825| r0_180(Middle *) = ConvertToBase[Derived : Middle] : r0_179
|
||||
# 825| r0_181(Base *) = ConvertToBase[Middle : Base] : r0_180
|
||||
# 825| r0_182(glval<Base *>) = VariableAddress[pb] :
|
||||
# 825| mu0_183(Base *) = Store : &:r0_182, r0_181
|
||||
# 826| r0_184(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 826| r0_185(Derived *) = Load : &:r0_184, ~mu0_2
|
||||
# 826| r0_186(Middle *) = ConvertToBase[Derived : Middle] : r0_185
|
||||
# 826| r0_187(Base *) = ConvertToBase[Middle : Base] : r0_186
|
||||
# 826| r0_188(glval<Base *>) = VariableAddress[pb] :
|
||||
# 826| mu0_189(Base *) = Store : &:r0_188, r0_187
|
||||
# 827| r0_190(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 827| r0_191(Derived *) = Load : &:r0_190, ~mu0_2
|
||||
# 827| r0_192(Middle *) = ConvertToBase[Derived : Middle] : r0_191
|
||||
# 827| r0_193(Base *) = ConvertToBase[Middle : Base] : r0_192
|
||||
# 827| r0_194(glval<Base *>) = VariableAddress[pb] :
|
||||
# 827| mu0_195(Base *) = Store : &:r0_194, r0_193
|
||||
# 828| r0_196(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 828| r0_197(Derived *) = Load : &:r0_196, ~mu0_2
|
||||
# 828| r0_198(Base *) = Convert : r0_197
|
||||
# 828| r0_199(glval<Base *>) = VariableAddress[pb] :
|
||||
# 828| mu0_200(Base *) = Store : &:r0_199, r0_198
|
||||
# 830| r0_201(glval<Derived>) = VariableAddress[d] :
|
||||
# 830| r0_202(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 830| r0_203(glval<Base>) = VariableAddress[b] :
|
||||
# 830| r0_204(glval<Middle>) = ConvertToDerived[Middle : Base] : r0_203
|
||||
# 830| r0_205(glval<Derived>) = ConvertToDerived[Derived : Middle] : r0_204
|
||||
# 830| r0_206(glval<Derived>) = Convert : r0_205
|
||||
# 830| r0_207(Derived &) = Call : func:r0_202, this:r0_201, 0:r0_206
|
||||
# 830| mu0_208(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 830| v0_209(void) = ^IndirectReadSideEffect[-1] : &:r0_201, ~mu0_2
|
||||
# 830| v0_210(void) = ^IndirectReadSideEffect[0] : &:r0_206, ~mu0_2
|
||||
# 830| mu0_211(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r0_201
|
||||
# 830| mu0_212(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_206
|
||||
# 831| r0_213(glval<Derived>) = VariableAddress[d] :
|
||||
# 831| r0_214(glval<unknown>) = FunctionAddress[operator=] :
|
||||
# 831| r0_215(glval<Base>) = VariableAddress[b] :
|
||||
# 831| r0_216(glval<Middle>) = ConvertToDerived[Middle : Base] : r0_215
|
||||
# 831| r0_217(glval<Derived>) = ConvertToDerived[Derived : Middle] : r0_216
|
||||
# 831| r0_218(glval<Derived>) = Convert : r0_217
|
||||
# 831| r0_219(Derived &) = Call : func:r0_214, this:r0_213, 0:r0_218
|
||||
# 831| mu0_220(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 831| v0_221(void) = ^IndirectReadSideEffect[-1] : &:r0_213, ~mu0_2
|
||||
# 831| v0_222(void) = ^IndirectReadSideEffect[0] : &:r0_218, ~mu0_2
|
||||
# 831| mu0_223(Derived) = ^IndirectMayWriteSideEffect[-1] : &:r0_213
|
||||
# 831| mu0_224(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_218
|
||||
# 832| r0_225(glval<Base *>) = VariableAddress[pb] :
|
||||
# 832| r0_226(Base *) = Load : &:r0_225, ~mu0_2
|
||||
# 832| r0_227(Middle *) = ConvertToDerived[Middle : Base] : r0_226
|
||||
# 832| r0_228(Derived *) = ConvertToDerived[Derived : Middle] : r0_227
|
||||
# 832| r0_229(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 832| mu0_230(Derived *) = Store : &:r0_229, r0_228
|
||||
# 833| r0_231(glval<Base *>) = VariableAddress[pb] :
|
||||
# 833| r0_232(Base *) = Load : &:r0_231, ~mu0_2
|
||||
# 833| r0_233(Middle *) = ConvertToDerived[Middle : Base] : r0_232
|
||||
# 833| r0_234(Derived *) = ConvertToDerived[Derived : Middle] : r0_233
|
||||
# 833| r0_235(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 833| mu0_236(Derived *) = Store : &:r0_235, r0_234
|
||||
# 834| r0_237(glval<Base *>) = VariableAddress[pb] :
|
||||
# 834| r0_238(Base *) = Load : &:r0_237, ~mu0_2
|
||||
# 834| r0_239(Derived *) = Convert : r0_238
|
||||
# 834| r0_240(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 834| mu0_241(Derived *) = Store : &:r0_240, r0_239
|
||||
# 836| r0_242(glval<MiddleVB1 *>) = VariableAddress[pmv] :
|
||||
# 836| r0_243(MiddleVB1 *) = Constant[0] :
|
||||
# 836| mu0_244(MiddleVB1 *) = Store : &:r0_242, r0_243
|
||||
# 837| r0_245(glval<DerivedVB *>) = VariableAddress[pdv] :
|
||||
# 837| r0_246(DerivedVB *) = Constant[0] :
|
||||
# 837| mu0_247(DerivedVB *) = Store : &:r0_245, r0_246
|
||||
# 838| r0_248(glval<MiddleVB1 *>) = VariableAddress[pmv] :
|
||||
# 838| r0_249(MiddleVB1 *) = Load : &:r0_248, ~mu0_2
|
||||
# 838| r0_250(Base *) = ConvertToVirtualBase[MiddleVB1 : Base] : r0_249
|
||||
# 838| r0_251(glval<Base *>) = VariableAddress[pb] :
|
||||
# 838| mu0_252(Base *) = Store : &:r0_251, r0_250
|
||||
# 839| r0_253(glval<DerivedVB *>) = VariableAddress[pdv] :
|
||||
# 839| r0_254(DerivedVB *) = Load : &:r0_253, ~mu0_2
|
||||
# 839| r0_255(Base *) = ConvertToVirtualBase[DerivedVB : Base] : r0_254
|
||||
# 839| r0_256(glval<Base *>) = VariableAddress[pb] :
|
||||
# 839| mu0_257(Base *) = Store : &:r0_256, r0_255
|
||||
# 840| v0_258(void) = NoOp :
|
||||
# 799| v0_259(void) = ReturnVoid :
|
||||
# 799| v0_260(void) = UnmodeledUse : mu*
|
||||
# 799| v0_261(void) = ExitFunction :
|
||||
|
||||
# 842| void PolymorphicBase::PolymorphicBase()
|
||||
# 842| Block 0
|
||||
@@ -3944,53 +3950,55 @@ ir.cpp:
|
||||
# 849| mu0_1(unknown) = AliasedDefinition :
|
||||
# 849| mu0_2(unknown) = UnmodeledDefinition :
|
||||
# 850| r0_3(glval<PolymorphicBase>) = VariableAddress[b] :
|
||||
#-----| r0_4(glval<unknown>) = FunctionAddress[PolymorphicBase] :
|
||||
#-----| v0_5(void) = Call : func:r0_4, this:r0_3
|
||||
#-----| mu0_6(unknown) = ^CallSideEffect : ~mu0_2
|
||||
#-----| mu0_7(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r0_3
|
||||
# 851| r0_8(glval<PolymorphicDerived>) = VariableAddress[d] :
|
||||
# 851| r0_9(glval<unknown>) = FunctionAddress[PolymorphicDerived] :
|
||||
# 851| v0_10(void) = Call : func:r0_9, this:r0_8
|
||||
# 851| mu0_11(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 851| mu0_12(PolymorphicDerived) = ^IndirectMayWriteSideEffect[-1] : &:r0_8
|
||||
# 853| r0_13(glval<PolymorphicBase *>) = VariableAddress[pb] :
|
||||
# 853| r0_14(glval<PolymorphicBase>) = VariableAddress[b] :
|
||||
# 853| mu0_15(PolymorphicBase *) = Store : &:r0_13, r0_14
|
||||
# 854| r0_16(glval<PolymorphicDerived *>) = VariableAddress[pd] :
|
||||
# 854| r0_17(glval<PolymorphicDerived>) = VariableAddress[d] :
|
||||
# 854| mu0_18(PolymorphicDerived *) = Store : &:r0_16, r0_17
|
||||
# 857| r0_19(glval<PolymorphicDerived *>) = VariableAddress[pd] :
|
||||
# 857| r0_20(PolymorphicDerived *) = Load : &:r0_19, ~mu0_2
|
||||
# 857| r0_21(PolymorphicBase *) = CheckedConvertOrNull : r0_20
|
||||
# 857| r0_22(glval<PolymorphicBase *>) = VariableAddress[pb] :
|
||||
# 857| mu0_23(PolymorphicBase *) = Store : &:r0_22, r0_21
|
||||
# 858| r0_24(glval<PolymorphicBase &>) = VariableAddress[rb] :
|
||||
# 858| r0_25(glval<PolymorphicDerived>) = VariableAddress[d] :
|
||||
# 858| r0_26(glval<PolymorphicBase>) = CheckedConvertOrThrow : r0_25
|
||||
# 858| mu0_27(PolymorphicBase &) = Store : &:r0_24, r0_26
|
||||
# 860| r0_28(glval<PolymorphicBase *>) = VariableAddress[pb] :
|
||||
# 860| r0_29(PolymorphicBase *) = Load : &:r0_28, ~mu0_2
|
||||
# 860| r0_30(PolymorphicDerived *) = CheckedConvertOrNull : r0_29
|
||||
# 860| r0_31(glval<PolymorphicDerived *>) = VariableAddress[pd] :
|
||||
# 860| mu0_32(PolymorphicDerived *) = Store : &:r0_31, r0_30
|
||||
# 861| r0_33(glval<PolymorphicDerived &>) = VariableAddress[rd] :
|
||||
# 861| r0_34(glval<PolymorphicBase>) = VariableAddress[b] :
|
||||
# 861| r0_35(glval<PolymorphicDerived>) = CheckedConvertOrThrow : r0_34
|
||||
# 861| mu0_36(PolymorphicDerived &) = Store : &:r0_33, r0_35
|
||||
# 863| r0_37(glval<void *>) = VariableAddress[pv] :
|
||||
# 863| r0_38(glval<PolymorphicBase *>) = VariableAddress[pb] :
|
||||
# 863| r0_39(PolymorphicBase *) = Load : &:r0_38, ~mu0_2
|
||||
# 863| r0_40(void *) = DynamicCastToVoid : r0_39
|
||||
# 863| mu0_41(void *) = Store : &:r0_37, r0_40
|
||||
# 864| r0_42(glval<void *>) = VariableAddress[pcv] :
|
||||
# 864| r0_43(glval<PolymorphicDerived *>) = VariableAddress[pd] :
|
||||
# 864| r0_44(PolymorphicDerived *) = Load : &:r0_43, ~mu0_2
|
||||
# 864| r0_45(void *) = DynamicCastToVoid : r0_44
|
||||
# 864| mu0_46(void *) = Store : &:r0_42, r0_45
|
||||
# 865| v0_47(void) = NoOp :
|
||||
# 849| v0_48(void) = ReturnVoid :
|
||||
# 849| v0_49(void) = UnmodeledUse : mu*
|
||||
# 849| v0_50(void) = ExitFunction :
|
||||
# 850| mu0_4(PolymorphicBase) = Uninitialized[b] : &:r0_3
|
||||
#-----| r0_5(glval<unknown>) = FunctionAddress[PolymorphicBase] :
|
||||
#-----| v0_6(void) = Call : func:r0_5, this:r0_3
|
||||
#-----| mu0_7(unknown) = ^CallSideEffect : ~mu0_2
|
||||
#-----| mu0_8(PolymorphicBase) = ^IndirectMayWriteSideEffect[-1] : &:r0_3
|
||||
# 851| r0_9(glval<PolymorphicDerived>) = VariableAddress[d] :
|
||||
# 851| mu0_10(PolymorphicDerived) = Uninitialized[d] : &:r0_9
|
||||
# 851| r0_11(glval<unknown>) = FunctionAddress[PolymorphicDerived] :
|
||||
# 851| v0_12(void) = Call : func:r0_11, this:r0_9
|
||||
# 851| mu0_13(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 851| mu0_14(PolymorphicDerived) = ^IndirectMayWriteSideEffect[-1] : &:r0_9
|
||||
# 853| r0_15(glval<PolymorphicBase *>) = VariableAddress[pb] :
|
||||
# 853| r0_16(glval<PolymorphicBase>) = VariableAddress[b] :
|
||||
# 853| mu0_17(PolymorphicBase *) = Store : &:r0_15, r0_16
|
||||
# 854| r0_18(glval<PolymorphicDerived *>) = VariableAddress[pd] :
|
||||
# 854| r0_19(glval<PolymorphicDerived>) = VariableAddress[d] :
|
||||
# 854| mu0_20(PolymorphicDerived *) = Store : &:r0_18, r0_19
|
||||
# 857| r0_21(glval<PolymorphicDerived *>) = VariableAddress[pd] :
|
||||
# 857| r0_22(PolymorphicDerived *) = Load : &:r0_21, ~mu0_2
|
||||
# 857| r0_23(PolymorphicBase *) = CheckedConvertOrNull : r0_22
|
||||
# 857| r0_24(glval<PolymorphicBase *>) = VariableAddress[pb] :
|
||||
# 857| mu0_25(PolymorphicBase *) = Store : &:r0_24, r0_23
|
||||
# 858| r0_26(glval<PolymorphicBase &>) = VariableAddress[rb] :
|
||||
# 858| r0_27(glval<PolymorphicDerived>) = VariableAddress[d] :
|
||||
# 858| r0_28(glval<PolymorphicBase>) = CheckedConvertOrThrow : r0_27
|
||||
# 858| mu0_29(PolymorphicBase &) = Store : &:r0_26, r0_28
|
||||
# 860| r0_30(glval<PolymorphicBase *>) = VariableAddress[pb] :
|
||||
# 860| r0_31(PolymorphicBase *) = Load : &:r0_30, ~mu0_2
|
||||
# 860| r0_32(PolymorphicDerived *) = CheckedConvertOrNull : r0_31
|
||||
# 860| r0_33(glval<PolymorphicDerived *>) = VariableAddress[pd] :
|
||||
# 860| mu0_34(PolymorphicDerived *) = Store : &:r0_33, r0_32
|
||||
# 861| r0_35(glval<PolymorphicDerived &>) = VariableAddress[rd] :
|
||||
# 861| r0_36(glval<PolymorphicBase>) = VariableAddress[b] :
|
||||
# 861| r0_37(glval<PolymorphicDerived>) = CheckedConvertOrThrow : r0_36
|
||||
# 861| mu0_38(PolymorphicDerived &) = Store : &:r0_35, r0_37
|
||||
# 863| r0_39(glval<void *>) = VariableAddress[pv] :
|
||||
# 863| r0_40(glval<PolymorphicBase *>) = VariableAddress[pb] :
|
||||
# 863| r0_41(PolymorphicBase *) = Load : &:r0_40, ~mu0_2
|
||||
# 863| r0_42(void *) = DynamicCastToVoid : r0_41
|
||||
# 863| mu0_43(void *) = Store : &:r0_39, r0_42
|
||||
# 864| r0_44(glval<void *>) = VariableAddress[pcv] :
|
||||
# 864| r0_45(glval<PolymorphicDerived *>) = VariableAddress[pd] :
|
||||
# 864| r0_46(PolymorphicDerived *) = Load : &:r0_45, ~mu0_2
|
||||
# 864| r0_47(void *) = DynamicCastToVoid : r0_46
|
||||
# 864| mu0_48(void *) = Store : &:r0_44, r0_47
|
||||
# 865| v0_49(void) = NoOp :
|
||||
# 849| v0_50(void) = ReturnVoid :
|
||||
# 849| v0_51(void) = UnmodeledUse : mu*
|
||||
# 849| v0_52(void) = ExitFunction :
|
||||
|
||||
# 867| void String::String()
|
||||
# 867| Block 0
|
||||
@@ -4714,133 +4722,135 @@ ir.cpp:
|
||||
# 1035| v0_31(void) = ^IndirectReadSideEffect[-1] : &:r0_26, ~mu0_2
|
||||
# 1035| mu0_32(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_26
|
||||
# 1036| r0_33(glval<decltype([...](...){...})>) = VariableAddress[lambda_val] :
|
||||
# 1036| r0_34(glval<unknown>) = FunctionAddress[(constructor)] :
|
||||
# 1036| r0_35(glval<decltype([...](...){...})>) = VariableAddress[#temp1036:21] :
|
||||
# 1036| mu0_36(decltype([...](...){...})) = Uninitialized[#temp1036:21] : &:r0_35
|
||||
# 1036| r0_37(glval<String>) = FieldAddress[s] : r0_35
|
||||
#-----| r0_38(glval<unknown>) = FunctionAddress[String] :
|
||||
#-----| v0_39(void) = Call : func:r0_38, this:r0_37
|
||||
#-----| mu0_40(unknown) = ^CallSideEffect : ~mu0_2
|
||||
#-----| mu0_41(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_37
|
||||
# 1036| r0_42(glval<int>) = FieldAddress[x] : r0_35
|
||||
#-----| r0_43(glval<int>) = VariableAddress[x] :
|
||||
#-----| r0_44(int) = Load : &:r0_43, ~mu0_2
|
||||
#-----| mu0_45(int) = Store : &:r0_42, r0_44
|
||||
# 1036| r0_46(decltype([...](...){...})) = Load : &:r0_35, ~mu0_2
|
||||
# 1036| v0_47(void) = Call : func:r0_34, this:r0_33, 0:r0_46
|
||||
# 1036| mu0_48(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1036| mu0_49(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_33
|
||||
# 1036| v0_50(void) = ^IndirectReadSideEffect[0] : &:r0_46, ~mu0_2
|
||||
# 1036| mu0_51(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_46
|
||||
# 1037| r0_52(glval<decltype([...](...){...})>) = VariableAddress[lambda_val] :
|
||||
# 1037| r0_53(glval<decltype([...](...){...})>) = Convert : r0_52
|
||||
# 1037| r0_54(glval<unknown>) = FunctionAddress[operator()] :
|
||||
# 1037| r0_55(float) = Constant[2.0] :
|
||||
# 1037| r0_56(char) = Call : func:r0_54, this:r0_53, 0:r0_55
|
||||
# 1037| mu0_57(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1037| v0_58(void) = ^IndirectReadSideEffect[-1] : &:r0_53, ~mu0_2
|
||||
# 1037| mu0_59(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_53
|
||||
# 1038| r0_60(glval<decltype([...](...){...})>) = VariableAddress[lambda_ref_explicit] :
|
||||
# 1038| r0_61(glval<decltype([...](...){...})>) = VariableAddress[#temp1038:30] :
|
||||
# 1038| mu0_62(decltype([...](...){...})) = Uninitialized[#temp1038:30] : &:r0_61
|
||||
# 1038| r0_63(glval<String &>) = FieldAddress[s] : r0_61
|
||||
# 1038| r0_64(glval<String &>) = VariableAddress[s] :
|
||||
# 1038| r0_65(String &) = Load : &:r0_64, ~mu0_2
|
||||
# 1038| mu0_66(String &) = Store : &:r0_63, r0_65
|
||||
# 1038| r0_67(decltype([...](...){...})) = Load : &:r0_61, ~mu0_2
|
||||
# 1038| mu0_68(decltype([...](...){...})) = Store : &:r0_60, r0_67
|
||||
# 1039| r0_69(glval<decltype([...](...){...})>) = VariableAddress[lambda_ref_explicit] :
|
||||
# 1039| r0_70(glval<decltype([...](...){...})>) = Convert : r0_69
|
||||
# 1039| r0_71(glval<unknown>) = FunctionAddress[operator()] :
|
||||
# 1039| r0_72(float) = Constant[3.0] :
|
||||
# 1039| r0_73(char) = Call : func:r0_71, this:r0_70, 0:r0_72
|
||||
# 1039| mu0_74(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1039| v0_75(void) = ^IndirectReadSideEffect[-1] : &:r0_70, ~mu0_2
|
||||
# 1039| mu0_76(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_70
|
||||
# 1040| r0_77(glval<decltype([...](...){...})>) = VariableAddress[lambda_val_explicit] :
|
||||
# 1040| r0_78(glval<unknown>) = FunctionAddress[(constructor)] :
|
||||
# 1040| r0_79(glval<decltype([...](...){...})>) = VariableAddress[#temp1040:30] :
|
||||
# 1040| mu0_80(decltype([...](...){...})) = Uninitialized[#temp1040:30] : &:r0_79
|
||||
# 1040| r0_81(glval<String>) = FieldAddress[s] : r0_79
|
||||
#-----| r0_82(glval<unknown>) = FunctionAddress[String] :
|
||||
#-----| v0_83(void) = Call : func:r0_82, this:r0_81
|
||||
#-----| mu0_84(unknown) = ^CallSideEffect : ~mu0_2
|
||||
#-----| mu0_85(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_81
|
||||
# 1040| r0_86(decltype([...](...){...})) = Load : &:r0_79, ~mu0_2
|
||||
# 1040| v0_87(void) = Call : func:r0_78, this:r0_77, 0:r0_86
|
||||
# 1040| mu0_88(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1040| mu0_89(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_77
|
||||
# 1040| v0_90(void) = ^IndirectReadSideEffect[0] : &:r0_86, ~mu0_2
|
||||
# 1040| mu0_91(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_86
|
||||
# 1041| r0_92(glval<decltype([...](...){...})>) = VariableAddress[lambda_val_explicit] :
|
||||
# 1041| r0_93(glval<decltype([...](...){...})>) = Convert : r0_92
|
||||
# 1041| r0_94(glval<unknown>) = FunctionAddress[operator()] :
|
||||
# 1041| r0_95(float) = Constant[4.0] :
|
||||
# 1041| r0_96(char) = Call : func:r0_94, this:r0_93, 0:r0_95
|
||||
# 1041| mu0_97(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1041| v0_98(void) = ^IndirectReadSideEffect[-1] : &:r0_93, ~mu0_2
|
||||
# 1041| mu0_99(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_93
|
||||
# 1042| r0_100(glval<decltype([...](...){...})>) = VariableAddress[lambda_mixed_explicit] :
|
||||
# 1042| r0_101(glval<decltype([...](...){...})>) = VariableAddress[#temp1042:32] :
|
||||
# 1042| mu0_102(decltype([...](...){...})) = Uninitialized[#temp1042:32] : &:r0_101
|
||||
# 1042| r0_103(glval<String &>) = FieldAddress[s] : r0_101
|
||||
# 1042| r0_104(glval<String &>) = VariableAddress[s] :
|
||||
# 1042| r0_105(String &) = Load : &:r0_104, ~mu0_2
|
||||
# 1042| mu0_106(String &) = Store : &:r0_103, r0_105
|
||||
# 1042| r0_107(glval<int>) = FieldAddress[x] : r0_101
|
||||
# 1042| r0_108(glval<int>) = VariableAddress[x] :
|
||||
# 1042| r0_109(int) = Load : &:r0_108, ~mu0_2
|
||||
# 1042| mu0_110(int) = Store : &:r0_107, r0_109
|
||||
# 1042| r0_111(decltype([...](...){...})) = Load : &:r0_101, ~mu0_2
|
||||
# 1042| mu0_112(decltype([...](...){...})) = Store : &:r0_100, r0_111
|
||||
# 1043| r0_113(glval<decltype([...](...){...})>) = VariableAddress[lambda_mixed_explicit] :
|
||||
# 1043| r0_114(glval<decltype([...](...){...})>) = Convert : r0_113
|
||||
# 1043| r0_115(glval<unknown>) = FunctionAddress[operator()] :
|
||||
# 1043| r0_116(float) = Constant[5.0] :
|
||||
# 1043| r0_117(char) = Call : func:r0_115, this:r0_114, 0:r0_116
|
||||
# 1043| mu0_118(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1043| v0_119(void) = ^IndirectReadSideEffect[-1] : &:r0_114, ~mu0_2
|
||||
# 1043| mu0_120(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_114
|
||||
# 1044| r0_121(glval<int>) = VariableAddress[r] :
|
||||
# 1044| r0_122(glval<int>) = VariableAddress[x] :
|
||||
# 1044| r0_123(int) = Load : &:r0_122, ~mu0_2
|
||||
# 1044| r0_124(int) = Constant[1] :
|
||||
# 1044| r0_125(int) = Sub : r0_123, r0_124
|
||||
# 1044| mu0_126(int) = Store : &:r0_121, r0_125
|
||||
# 1045| r0_127(glval<decltype([...](...){...})>) = VariableAddress[lambda_inits] :
|
||||
# 1045| r0_128(glval<decltype([...](...){...})>) = VariableAddress[#temp1045:23] :
|
||||
# 1045| mu0_129(decltype([...](...){...})) = Uninitialized[#temp1045:23] : &:r0_128
|
||||
# 1045| r0_130(glval<String &>) = FieldAddress[s] : r0_128
|
||||
# 1045| r0_131(glval<String &>) = VariableAddress[s] :
|
||||
# 1045| r0_132(String &) = Load : &:r0_131, ~mu0_2
|
||||
# 1045| mu0_133(String &) = Store : &:r0_130, r0_132
|
||||
# 1045| r0_134(glval<int>) = FieldAddress[x] : r0_128
|
||||
# 1045| r0_135(glval<int>) = VariableAddress[x] :
|
||||
# 1045| r0_136(int) = Load : &:r0_135, ~mu0_2
|
||||
# 1045| mu0_137(int) = Store : &:r0_134, r0_136
|
||||
# 1045| r0_138(glval<int>) = FieldAddress[i] : r0_128
|
||||
# 1045| r0_139(glval<int>) = VariableAddress[x] :
|
||||
# 1045| r0_140(int) = Load : &:r0_139, ~mu0_2
|
||||
# 1045| r0_141(int) = Constant[1] :
|
||||
# 1045| r0_142(int) = Add : r0_140, r0_141
|
||||
# 1045| mu0_143(int) = Store : &:r0_138, r0_142
|
||||
# 1045| r0_144(glval<int &>) = FieldAddress[j] : r0_128
|
||||
# 1045| r0_145(glval<int>) = VariableAddress[r] :
|
||||
# 1045| mu0_146(int &) = Store : &:r0_144, r0_145
|
||||
# 1045| r0_147(decltype([...](...){...})) = Load : &:r0_128, ~mu0_2
|
||||
# 1045| mu0_148(decltype([...](...){...})) = Store : &:r0_127, r0_147
|
||||
# 1046| r0_149(glval<decltype([...](...){...})>) = VariableAddress[lambda_inits] :
|
||||
# 1046| r0_150(glval<decltype([...](...){...})>) = Convert : r0_149
|
||||
# 1046| r0_151(glval<unknown>) = FunctionAddress[operator()] :
|
||||
# 1046| r0_152(float) = Constant[6.0] :
|
||||
# 1046| r0_153(char) = Call : func:r0_151, this:r0_150, 0:r0_152
|
||||
# 1046| mu0_154(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1046| v0_155(void) = ^IndirectReadSideEffect[-1] : &:r0_150, ~mu0_2
|
||||
# 1046| mu0_156(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_150
|
||||
# 1047| v0_157(void) = NoOp :
|
||||
# 1031| v0_158(void) = ReturnVoid :
|
||||
# 1031| v0_159(void) = UnmodeledUse : mu*
|
||||
# 1031| v0_160(void) = ExitFunction :
|
||||
# 1036| mu0_34(decltype([...](...){...})) = Uninitialized[lambda_val] : &:r0_33
|
||||
# 1036| r0_35(glval<unknown>) = FunctionAddress[(constructor)] :
|
||||
# 1036| r0_36(glval<decltype([...](...){...})>) = VariableAddress[#temp1036:21] :
|
||||
# 1036| mu0_37(decltype([...](...){...})) = Uninitialized[#temp1036:21] : &:r0_36
|
||||
# 1036| r0_38(glval<String>) = FieldAddress[s] : r0_36
|
||||
#-----| r0_39(glval<unknown>) = FunctionAddress[String] :
|
||||
#-----| v0_40(void) = Call : func:r0_39, this:r0_38
|
||||
#-----| mu0_41(unknown) = ^CallSideEffect : ~mu0_2
|
||||
#-----| mu0_42(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_38
|
||||
# 1036| r0_43(glval<int>) = FieldAddress[x] : r0_36
|
||||
#-----| r0_44(glval<int>) = VariableAddress[x] :
|
||||
#-----| r0_45(int) = Load : &:r0_44, ~mu0_2
|
||||
#-----| mu0_46(int) = Store : &:r0_43, r0_45
|
||||
# 1036| r0_47(decltype([...](...){...})) = Load : &:r0_36, ~mu0_2
|
||||
# 1036| v0_48(void) = Call : func:r0_35, this:r0_33, 0:r0_47
|
||||
# 1036| mu0_49(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1036| mu0_50(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_33
|
||||
# 1036| v0_51(void) = ^IndirectReadSideEffect[0] : &:r0_47, ~mu0_2
|
||||
# 1036| mu0_52(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_47
|
||||
# 1037| r0_53(glval<decltype([...](...){...})>) = VariableAddress[lambda_val] :
|
||||
# 1037| r0_54(glval<decltype([...](...){...})>) = Convert : r0_53
|
||||
# 1037| r0_55(glval<unknown>) = FunctionAddress[operator()] :
|
||||
# 1037| r0_56(float) = Constant[2.0] :
|
||||
# 1037| r0_57(char) = Call : func:r0_55, this:r0_54, 0:r0_56
|
||||
# 1037| mu0_58(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1037| v0_59(void) = ^IndirectReadSideEffect[-1] : &:r0_54, ~mu0_2
|
||||
# 1037| mu0_60(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_54
|
||||
# 1038| r0_61(glval<decltype([...](...){...})>) = VariableAddress[lambda_ref_explicit] :
|
||||
# 1038| r0_62(glval<decltype([...](...){...})>) = VariableAddress[#temp1038:30] :
|
||||
# 1038| mu0_63(decltype([...](...){...})) = Uninitialized[#temp1038:30] : &:r0_62
|
||||
# 1038| r0_64(glval<String &>) = FieldAddress[s] : r0_62
|
||||
# 1038| r0_65(glval<String &>) = VariableAddress[s] :
|
||||
# 1038| r0_66(String &) = Load : &:r0_65, ~mu0_2
|
||||
# 1038| mu0_67(String &) = Store : &:r0_64, r0_66
|
||||
# 1038| r0_68(decltype([...](...){...})) = Load : &:r0_62, ~mu0_2
|
||||
# 1038| mu0_69(decltype([...](...){...})) = Store : &:r0_61, r0_68
|
||||
# 1039| r0_70(glval<decltype([...](...){...})>) = VariableAddress[lambda_ref_explicit] :
|
||||
# 1039| r0_71(glval<decltype([...](...){...})>) = Convert : r0_70
|
||||
# 1039| r0_72(glval<unknown>) = FunctionAddress[operator()] :
|
||||
# 1039| r0_73(float) = Constant[3.0] :
|
||||
# 1039| r0_74(char) = Call : func:r0_72, this:r0_71, 0:r0_73
|
||||
# 1039| mu0_75(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1039| v0_76(void) = ^IndirectReadSideEffect[-1] : &:r0_71, ~mu0_2
|
||||
# 1039| mu0_77(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_71
|
||||
# 1040| r0_78(glval<decltype([...](...){...})>) = VariableAddress[lambda_val_explicit] :
|
||||
# 1040| mu0_79(decltype([...](...){...})) = Uninitialized[lambda_val_explicit] : &:r0_78
|
||||
# 1040| r0_80(glval<unknown>) = FunctionAddress[(constructor)] :
|
||||
# 1040| r0_81(glval<decltype([...](...){...})>) = VariableAddress[#temp1040:30] :
|
||||
# 1040| mu0_82(decltype([...](...){...})) = Uninitialized[#temp1040:30] : &:r0_81
|
||||
# 1040| r0_83(glval<String>) = FieldAddress[s] : r0_81
|
||||
#-----| r0_84(glval<unknown>) = FunctionAddress[String] :
|
||||
#-----| v0_85(void) = Call : func:r0_84, this:r0_83
|
||||
#-----| mu0_86(unknown) = ^CallSideEffect : ~mu0_2
|
||||
#-----| mu0_87(String) = ^IndirectMayWriteSideEffect[-1] : &:r0_83
|
||||
# 1040| r0_88(decltype([...](...){...})) = Load : &:r0_81, ~mu0_2
|
||||
# 1040| v0_89(void) = Call : func:r0_80, this:r0_78, 0:r0_88
|
||||
# 1040| mu0_90(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1040| mu0_91(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_78
|
||||
# 1040| v0_92(void) = ^IndirectReadSideEffect[0] : &:r0_88, ~mu0_2
|
||||
# 1040| mu0_93(unknown) = ^BufferMayWriteSideEffect[0] : &:r0_88
|
||||
# 1041| r0_94(glval<decltype([...](...){...})>) = VariableAddress[lambda_val_explicit] :
|
||||
# 1041| r0_95(glval<decltype([...](...){...})>) = Convert : r0_94
|
||||
# 1041| r0_96(glval<unknown>) = FunctionAddress[operator()] :
|
||||
# 1041| r0_97(float) = Constant[4.0] :
|
||||
# 1041| r0_98(char) = Call : func:r0_96, this:r0_95, 0:r0_97
|
||||
# 1041| mu0_99(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1041| v0_100(void) = ^IndirectReadSideEffect[-1] : &:r0_95, ~mu0_2
|
||||
# 1041| mu0_101(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_95
|
||||
# 1042| r0_102(glval<decltype([...](...){...})>) = VariableAddress[lambda_mixed_explicit] :
|
||||
# 1042| r0_103(glval<decltype([...](...){...})>) = VariableAddress[#temp1042:32] :
|
||||
# 1042| mu0_104(decltype([...](...){...})) = Uninitialized[#temp1042:32] : &:r0_103
|
||||
# 1042| r0_105(glval<String &>) = FieldAddress[s] : r0_103
|
||||
# 1042| r0_106(glval<String &>) = VariableAddress[s] :
|
||||
# 1042| r0_107(String &) = Load : &:r0_106, ~mu0_2
|
||||
# 1042| mu0_108(String &) = Store : &:r0_105, r0_107
|
||||
# 1042| r0_109(glval<int>) = FieldAddress[x] : r0_103
|
||||
# 1042| r0_110(glval<int>) = VariableAddress[x] :
|
||||
# 1042| r0_111(int) = Load : &:r0_110, ~mu0_2
|
||||
# 1042| mu0_112(int) = Store : &:r0_109, r0_111
|
||||
# 1042| r0_113(decltype([...](...){...})) = Load : &:r0_103, ~mu0_2
|
||||
# 1042| mu0_114(decltype([...](...){...})) = Store : &:r0_102, r0_113
|
||||
# 1043| r0_115(glval<decltype([...](...){...})>) = VariableAddress[lambda_mixed_explicit] :
|
||||
# 1043| r0_116(glval<decltype([...](...){...})>) = Convert : r0_115
|
||||
# 1043| r0_117(glval<unknown>) = FunctionAddress[operator()] :
|
||||
# 1043| r0_118(float) = Constant[5.0] :
|
||||
# 1043| r0_119(char) = Call : func:r0_117, this:r0_116, 0:r0_118
|
||||
# 1043| mu0_120(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1043| v0_121(void) = ^IndirectReadSideEffect[-1] : &:r0_116, ~mu0_2
|
||||
# 1043| mu0_122(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_116
|
||||
# 1044| r0_123(glval<int>) = VariableAddress[r] :
|
||||
# 1044| r0_124(glval<int>) = VariableAddress[x] :
|
||||
# 1044| r0_125(int) = Load : &:r0_124, ~mu0_2
|
||||
# 1044| r0_126(int) = Constant[1] :
|
||||
# 1044| r0_127(int) = Sub : r0_125, r0_126
|
||||
# 1044| mu0_128(int) = Store : &:r0_123, r0_127
|
||||
# 1045| r0_129(glval<decltype([...](...){...})>) = VariableAddress[lambda_inits] :
|
||||
# 1045| r0_130(glval<decltype([...](...){...})>) = VariableAddress[#temp1045:23] :
|
||||
# 1045| mu0_131(decltype([...](...){...})) = Uninitialized[#temp1045:23] : &:r0_130
|
||||
# 1045| r0_132(glval<String &>) = FieldAddress[s] : r0_130
|
||||
# 1045| r0_133(glval<String &>) = VariableAddress[s] :
|
||||
# 1045| r0_134(String &) = Load : &:r0_133, ~mu0_2
|
||||
# 1045| mu0_135(String &) = Store : &:r0_132, r0_134
|
||||
# 1045| r0_136(glval<int>) = FieldAddress[x] : r0_130
|
||||
# 1045| r0_137(glval<int>) = VariableAddress[x] :
|
||||
# 1045| r0_138(int) = Load : &:r0_137, ~mu0_2
|
||||
# 1045| mu0_139(int) = Store : &:r0_136, r0_138
|
||||
# 1045| r0_140(glval<int>) = FieldAddress[i] : r0_130
|
||||
# 1045| r0_141(glval<int>) = VariableAddress[x] :
|
||||
# 1045| r0_142(int) = Load : &:r0_141, ~mu0_2
|
||||
# 1045| r0_143(int) = Constant[1] :
|
||||
# 1045| r0_144(int) = Add : r0_142, r0_143
|
||||
# 1045| mu0_145(int) = Store : &:r0_140, r0_144
|
||||
# 1045| r0_146(glval<int &>) = FieldAddress[j] : r0_130
|
||||
# 1045| r0_147(glval<int>) = VariableAddress[r] :
|
||||
# 1045| mu0_148(int &) = Store : &:r0_146, r0_147
|
||||
# 1045| r0_149(decltype([...](...){...})) = Load : &:r0_130, ~mu0_2
|
||||
# 1045| mu0_150(decltype([...](...){...})) = Store : &:r0_129, r0_149
|
||||
# 1046| r0_151(glval<decltype([...](...){...})>) = VariableAddress[lambda_inits] :
|
||||
# 1046| r0_152(glval<decltype([...](...){...})>) = Convert : r0_151
|
||||
# 1046| r0_153(glval<unknown>) = FunctionAddress[operator()] :
|
||||
# 1046| r0_154(float) = Constant[6.0] :
|
||||
# 1046| r0_155(char) = Call : func:r0_153, this:r0_152, 0:r0_154
|
||||
# 1046| mu0_156(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 1046| v0_157(void) = ^IndirectReadSideEffect[-1] : &:r0_152, ~mu0_2
|
||||
# 1046| mu0_158(decltype([...](...){...})) = ^IndirectMayWriteSideEffect[-1] : &:r0_152
|
||||
# 1047| v0_159(void) = NoOp :
|
||||
# 1031| v0_160(void) = ReturnVoid :
|
||||
# 1031| v0_161(void) = UnmodeledUse : mu*
|
||||
# 1031| v0_162(void) = ExitFunction :
|
||||
|
||||
# 1032| void (void Lambda(int, String const&))::(lambda [] type at line 1032, col. 23)::(constructor)((void Lambda(int, String const&))::(lambda [] type at line 1032, col. 23)&&)
|
||||
# 1032| Block 0
|
||||
|
||||
@@ -884,36 +884,41 @@ ssa.cpp:
|
||||
# 220| m0_8(unknown) = ^CallSideEffect : ~m0_1
|
||||
# 220| m0_9(unknown) = Chi : total:m0_1, partial:m0_8
|
||||
# 220| m0_10(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_3
|
||||
# 221| r0_11(glval<Constructible>) = VariableAddress[c] :
|
||||
# 221| r0_12(glval<unknown>) = FunctionAddress[g] :
|
||||
# 221| v0_13(void) = Call : func:r0_12, this:r0_11
|
||||
# 221| m0_14(unknown) = ^CallSideEffect : ~m0_9
|
||||
# 221| m0_15(unknown) = Chi : total:m0_9, partial:m0_14
|
||||
# 221| v0_16(void) = ^IndirectReadSideEffect[-1] : &:r0_11, m0_10
|
||||
# 221| m0_17(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_11
|
||||
# 222| r0_18(glval<Constructible>) = VariableAddress[c] :
|
||||
# 222| r0_19(glval<unknown>) = FunctionAddress[g] :
|
||||
# 222| v0_20(void) = Call : func:r0_19, this:r0_18
|
||||
# 222| m0_21(unknown) = ^CallSideEffect : ~m0_15
|
||||
# 222| m0_22(unknown) = Chi : total:m0_15, partial:m0_21
|
||||
# 222| v0_23(void) = ^IndirectReadSideEffect[-1] : &:r0_18, m0_17
|
||||
# 222| m0_24(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_18
|
||||
# 223| r0_25(glval<Constructible>) = VariableAddress[c2] :
|
||||
# 223| m0_26(Constructible) = Uninitialized[c2] : &:r0_25
|
||||
# 223| r0_27(glval<unknown>) = FunctionAddress[Constructible] :
|
||||
# 223| r0_28(int) = Constant[2] :
|
||||
# 223| v0_29(void) = Call : func:r0_27, this:r0_25, 0:r0_28
|
||||
# 223| m0_30(unknown) = ^CallSideEffect : ~m0_22
|
||||
# 223| m0_31(unknown) = Chi : total:m0_22, partial:m0_30
|
||||
# 223| m0_32(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_25
|
||||
# 224| r0_33(glval<Constructible>) = VariableAddress[c2] :
|
||||
# 224| r0_34(glval<unknown>) = FunctionAddress[g] :
|
||||
# 224| v0_35(void) = Call : func:r0_34, this:r0_33
|
||||
# 224| m0_36(unknown) = ^CallSideEffect : ~m0_31
|
||||
# 224| m0_37(unknown) = Chi : total:m0_31, partial:m0_36
|
||||
# 224| v0_38(void) = ^IndirectReadSideEffect[-1] : &:r0_33, m0_32
|
||||
# 224| m0_39(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_33
|
||||
# 225| v0_40(void) = NoOp :
|
||||
# 219| v0_41(void) = ReturnVoid :
|
||||
# 219| v0_42(void) = UnmodeledUse : mu*
|
||||
# 219| v0_43(void) = ExitFunction :
|
||||
# 220| m0_11(Constructible) = Chi : total:m0_10, partial:m0_10
|
||||
# 221| r0_12(glval<Constructible>) = VariableAddress[c] :
|
||||
# 221| r0_13(glval<unknown>) = FunctionAddress[g] :
|
||||
# 221| v0_14(void) = Call : func:r0_13, this:r0_12
|
||||
# 221| m0_15(unknown) = ^CallSideEffect : ~m0_9
|
||||
# 221| m0_16(unknown) = Chi : total:m0_9, partial:m0_15
|
||||
# 221| v0_17(void) = ^IndirectReadSideEffect[-1] : &:r0_12, m0_10
|
||||
# 221| m0_18(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_12
|
||||
# 221| m0_19(Constructible) = Chi : total:m0_18, partial:m0_18
|
||||
# 222| r0_20(glval<Constructible>) = VariableAddress[c] :
|
||||
# 222| r0_21(glval<unknown>) = FunctionAddress[g] :
|
||||
# 222| v0_22(void) = Call : func:r0_21, this:r0_20
|
||||
# 222| m0_23(unknown) = ^CallSideEffect : ~m0_16
|
||||
# 222| m0_24(unknown) = Chi : total:m0_16, partial:m0_23
|
||||
# 222| v0_25(void) = ^IndirectReadSideEffect[-1] : &:r0_20, m0_18
|
||||
# 222| m0_26(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_20
|
||||
# 222| m0_27(Constructible) = Chi : total:m0_26, partial:m0_26
|
||||
# 223| r0_28(glval<Constructible>) = VariableAddress[c2] :
|
||||
# 223| m0_29(Constructible) = Uninitialized[c2] : &:r0_28
|
||||
# 223| r0_30(glval<unknown>) = FunctionAddress[Constructible] :
|
||||
# 223| r0_31(int) = Constant[2] :
|
||||
# 223| v0_32(void) = Call : func:r0_30, this:r0_28, 0:r0_31
|
||||
# 223| m0_33(unknown) = ^CallSideEffect : ~m0_24
|
||||
# 223| m0_34(unknown) = Chi : total:m0_24, partial:m0_33
|
||||
# 223| m0_35(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_28
|
||||
# 223| m0_36(Constructible) = Chi : total:m0_35, partial:m0_35
|
||||
# 224| r0_37(glval<Constructible>) = VariableAddress[c2] :
|
||||
# 224| r0_38(glval<unknown>) = FunctionAddress[g] :
|
||||
# 224| v0_39(void) = Call : func:r0_38, this:r0_37
|
||||
# 224| m0_40(unknown) = ^CallSideEffect : ~m0_34
|
||||
# 224| m0_41(unknown) = Chi : total:m0_34, partial:m0_40
|
||||
# 224| v0_42(void) = ^IndirectReadSideEffect[-1] : &:r0_37, m0_35
|
||||
# 224| m0_43(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_37
|
||||
# 224| m0_44(Constructible) = Chi : total:m0_43, partial:m0_43
|
||||
# 225| v0_45(void) = NoOp :
|
||||
# 219| v0_46(void) = ReturnVoid :
|
||||
# 219| v0_47(void) = UnmodeledUse : mu*
|
||||
# 219| v0_48(void) = ExitFunction :
|
||||
|
||||
@@ -837,37 +837,37 @@ ssa.cpp:
|
||||
# 219| mu0_1(unknown) = AliasedDefinition :
|
||||
# 219| mu0_2(unknown) = UnmodeledDefinition :
|
||||
# 220| r0_3(glval<Constructible>) = VariableAddress[c] :
|
||||
# 220| m0_4(Constructible) = Uninitialized[c] : &:r0_3
|
||||
# 220| mu0_4(Constructible) = Uninitialized[c] : &:r0_3
|
||||
# 220| r0_5(glval<unknown>) = FunctionAddress[Constructible] :
|
||||
# 220| r0_6(int) = Constant[1] :
|
||||
# 220| v0_7(void) = Call : func:r0_5, this:r0_3, 0:r0_6
|
||||
# 220| mu0_8(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 220| m0_9(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_3
|
||||
# 220| mu0_9(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_3
|
||||
# 221| r0_10(glval<Constructible>) = VariableAddress[c] :
|
||||
# 221| r0_11(glval<unknown>) = FunctionAddress[g] :
|
||||
# 221| v0_12(void) = Call : func:r0_11, this:r0_10
|
||||
# 221| mu0_13(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 221| v0_14(void) = ^IndirectReadSideEffect[-1] : &:r0_10, m0_9
|
||||
# 221| m0_15(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_10
|
||||
# 221| v0_14(void) = ^IndirectReadSideEffect[-1] : &:r0_10, ~mu0_2
|
||||
# 221| mu0_15(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_10
|
||||
# 222| r0_16(glval<Constructible>) = VariableAddress[c] :
|
||||
# 222| r0_17(glval<unknown>) = FunctionAddress[g] :
|
||||
# 222| v0_18(void) = Call : func:r0_17, this:r0_16
|
||||
# 222| mu0_19(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 222| v0_20(void) = ^IndirectReadSideEffect[-1] : &:r0_16, m0_15
|
||||
# 222| m0_21(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_16
|
||||
# 222| v0_20(void) = ^IndirectReadSideEffect[-1] : &:r0_16, ~mu0_2
|
||||
# 222| mu0_21(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_16
|
||||
# 223| r0_22(glval<Constructible>) = VariableAddress[c2] :
|
||||
# 223| m0_23(Constructible) = Uninitialized[c2] : &:r0_22
|
||||
# 223| mu0_23(Constructible) = Uninitialized[c2] : &:r0_22
|
||||
# 223| r0_24(glval<unknown>) = FunctionAddress[Constructible] :
|
||||
# 223| r0_25(int) = Constant[2] :
|
||||
# 223| v0_26(void) = Call : func:r0_24, this:r0_22, 0:r0_25
|
||||
# 223| mu0_27(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 223| m0_28(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_22
|
||||
# 223| mu0_28(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_22
|
||||
# 224| r0_29(glval<Constructible>) = VariableAddress[c2] :
|
||||
# 224| r0_30(glval<unknown>) = FunctionAddress[g] :
|
||||
# 224| v0_31(void) = Call : func:r0_30, this:r0_29
|
||||
# 224| mu0_32(unknown) = ^CallSideEffect : ~mu0_2
|
||||
# 224| v0_33(void) = ^IndirectReadSideEffect[-1] : &:r0_29, m0_28
|
||||
# 224| m0_34(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_29
|
||||
# 224| v0_33(void) = ^IndirectReadSideEffect[-1] : &:r0_29, ~mu0_2
|
||||
# 224| mu0_34(Constructible) = ^IndirectMayWriteSideEffect[-1] : &:r0_29
|
||||
# 225| v0_35(void) = NoOp :
|
||||
# 219| v0_36(void) = ReturnVoid :
|
||||
# 219| v0_37(void) = UnmodeledUse : mu*
|
||||
|
||||
Reference in New Issue
Block a user