mirror of
https://github.com/github/codeql.git
synced 2025-12-22 03:36:30 +01:00
Merge pull request #2740 from dbartol/dbartol/InitializeNonLocal
C++: Prevent `AliasedVirtualVariable` from overlapping string literals
This commit is contained in:
Jonas Jensen
@@ -63,6 +63,7 @@ private newtype TOpcode =
|
||||
TUnmodeledDefinition() or
|
||||
TUnmodeledUse() or
|
||||
TAliasedDefinition() or
|
||||
TInitializeNonLocal() or
|
||||
TAliasedUse() or
|
||||
TPhi() or
|
||||
TBuiltIn() or
|
||||
@@ -596,6 +597,14 @@ module Opcode {
|
||||
final override MemoryAccessKind getWriteMemoryAccess() { result instanceof EscapedMemoryAccess }
|
||||
}
|
||||
|
||||
class InitializeNonLocal extends Opcode, TInitializeNonLocal {
|
||||
final override string toString() { result = "InitializeNonLocal" }
|
||||
|
||||
final override MemoryAccessKind getWriteMemoryAccess() {
|
||||
result instanceof NonLocalMemoryAccess
|
||||
}
|
||||
}
|
||||
|
||||
class AliasedUse extends Opcode, TAliasedUse {
|
||||
final override string toString() { result = "AliasedUse" }
|
||||
|
||||
|
||||
@@ -298,7 +298,7 @@ class AllNonLocalMemory extends TAllNonLocalMemory, MemoryLocation {
|
||||
|
||||
final override string toStringInternal() { result = "{AllNonLocal}" }
|
||||
|
||||
final override VirtualVariable getVirtualVariable() { result = TAllAliasedMemory(irFunc, false) }
|
||||
final override AliasedVirtualVariable getVirtualVariable() { result.getIRFunction() = irFunc }
|
||||
|
||||
final override Language::LanguageType getType() {
|
||||
result = any(IRUnknownType type).getCanonicalLanguageType()
|
||||
@@ -311,6 +311,14 @@ class AllNonLocalMemory extends TAllNonLocalMemory, MemoryLocation {
|
||||
final override string getUniqueId() { result = "{AllNonLocal}" }
|
||||
|
||||
final override predicate isMayAccess() { isMayAccess = true }
|
||||
|
||||
override predicate canDefineReadOnly() {
|
||||
// A "must" access that defines all non-local memory appears only on the `InitializeNonLocal`
|
||||
// instruction, which provides the initial definition for all memory outside of the current
|
||||
// function's stack frame. This memory includes string literals and other read-only globals, so
|
||||
// we allow such an access to be the definition for a use of a read-only location.
|
||||
not isMayAccess()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -341,16 +349,6 @@ class AllAliasedMemory extends TAllAliasedMemory, MemoryLocation {
|
||||
|
||||
class AliasedVirtualVariable extends AllAliasedMemory, VirtualVariable {
|
||||
AliasedVirtualVariable() { not isMayAccess() }
|
||||
|
||||
override predicate canDefineReadOnly() {
|
||||
// A must-def of all aliased memory is only used in two places:
|
||||
// 1. In the prologue of the function, to provide a definition for all memory defined before the
|
||||
// function was called. In this case, it needs to provide a definition even for read-only
|
||||
// non-local variables.
|
||||
// 2. As the result of a `Chi` instruction. These don't participate in overlap analysis, so it's
|
||||
// OK if we let this predicate hold in that case.
|
||||
any()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -405,10 +403,16 @@ private Overlap getExtentOverlap(MemoryLocation def, MemoryLocation use) {
|
||||
use instanceof AllNonLocalMemory and
|
||||
result instanceof MustExactlyOverlap
|
||||
or
|
||||
// AllNonLocalMemory may partially overlap any location within the same virtual variable,
|
||||
// except a local variable.
|
||||
result instanceof MayPartiallyOverlap and
|
||||
not use.isAlwaysAllocatedOnStack()
|
||||
not use instanceof AllNonLocalMemory and
|
||||
not use.isAlwaysAllocatedOnStack() and
|
||||
if use instanceof VariableMemoryLocation
|
||||
then
|
||||
// AllNonLocalMemory totally overlaps any non-local variable.
|
||||
result instanceof MustTotallyOverlap
|
||||
else
|
||||
// AllNonLocalMemory may partially overlap any other location within the same virtual
|
||||
// variable, except a stack variable.
|
||||
result instanceof MayPartiallyOverlap
|
||||
)
|
||||
or
|
||||
def.getVirtualVariable() = use.getVirtualVariable() and
|
||||
|
||||
@@ -759,7 +759,21 @@ module DefUse {
|
||||
then defLocation = useLocation
|
||||
else (
|
||||
definitionHasPhiNode(defLocation, block) and
|
||||
defLocation = useLocation.getVirtualVariable()
|
||||
defLocation = useLocation.getVirtualVariable() and
|
||||
// Handle the unusual case where a virtual variable does not overlap one of its member
|
||||
// locations. For example, a definition of the virtual variable representing all aliased
|
||||
// memory does not overlap a use of a string literal, because the contents of a string
|
||||
// literal can never be redefined. The string literal's location could still be a member of
|
||||
// the `AliasedVirtualVariable` due to something like:
|
||||
// ```
|
||||
// char s[10];
|
||||
// strcpy(s, p);
|
||||
// const char* p = b ? "SomeLiteral" : s;
|
||||
// return p[3];
|
||||
// ```
|
||||
// In the above example, `p[3]` may access either the string literal or the local variable
|
||||
// `s`, so both of those locations must be members of the `AliasedVirtualVariable`.
|
||||
exists(Alias::getOverlap(defLocation, useLocation))
|
||||
)
|
||||
)
|
||||
or
|
||||
|
||||
@@ -28,6 +28,7 @@ newtype TInstructionTag =
|
||||
UnmodeledDefinitionTag() or
|
||||
UnmodeledUseTag() or
|
||||
AliasedDefinitionTag() or
|
||||
InitializeNonLocalTag() or
|
||||
AliasedUseTag() or
|
||||
SwitchBranchTag() or
|
||||
CallTargetTag() or
|
||||
@@ -126,6 +127,8 @@ string getInstructionTagId(TInstructionTag tag) {
|
||||
or
|
||||
tag = AliasedDefinitionTag() and result = "AliasedDef"
|
||||
or
|
||||
tag = InitializeNonLocalTag() and result = "InitNonLocal"
|
||||
or
|
||||
tag = AliasedUseTag() and result = "AliasedUse"
|
||||
or
|
||||
tag = SwitchBranchTag() and result = "SwitchBranch"
|
||||
|
||||
@@ -71,6 +71,9 @@ class TranslatedFunction extends TranslatedElement, TTranslatedFunction {
|
||||
result = getInstruction(AliasedDefinitionTag())
|
||||
or
|
||||
tag = AliasedDefinitionTag() and
|
||||
result = getInstruction(InitializeNonLocalTag())
|
||||
or
|
||||
tag = InitializeNonLocalTag() and
|
||||
result = getInstruction(UnmodeledDefinitionTag())
|
||||
or
|
||||
(
|
||||
@@ -144,6 +147,10 @@ class TranslatedFunction extends TranslatedElement, TTranslatedFunction {
|
||||
opcode instanceof Opcode::AliasedDefinition and
|
||||
resultType = getUnknownType()
|
||||
or
|
||||
tag = InitializeNonLocalTag() and
|
||||
opcode instanceof Opcode::InitializeNonLocal and
|
||||
resultType = getUnknownType()
|
||||
or
|
||||
tag = InitializeThisTag() and
|
||||
opcode instanceof Opcode::InitializeThis and
|
||||
resultType = getTypeForGLValue(getThisType())
|
||||
|
||||
@@ -759,7 +759,21 @@ module DefUse {
|
||||
then defLocation = useLocation
|
||||
else (
|
||||
definitionHasPhiNode(defLocation, block) and
|
||||
defLocation = useLocation.getVirtualVariable()
|
||||
defLocation = useLocation.getVirtualVariable() and
|
||||
// Handle the unusual case where a virtual variable does not overlap one of its member
|
||||
// locations. For example, a definition of the virtual variable representing all aliased
|
||||
// memory does not overlap a use of a string literal, because the contents of a string
|
||||
// literal can never be redefined. The string literal's location could still be a member of
|
||||
// the `AliasedVirtualVariable` due to something like:
|
||||
// ```
|
||||
// char s[10];
|
||||
// strcpy(s, p);
|
||||
// const char* p = b ? "SomeLiteral" : s;
|
||||
// return p[3];
|
||||
// ```
|
||||
// In the above example, `p[3]` may access either the string literal or the local variable
|
||||
// `s`, so both of those locations must be members of the `AliasedVirtualVariable`.
|
||||
exists(Alias::getOverlap(defLocation, useLocation))
|
||||
)
|
||||
)
|
||||
or
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -249,4 +249,16 @@ char *VoidStarIndirectParameters(char *src, int size) {
|
||||
*src = 'a';
|
||||
memcpy(dst, src, size);
|
||||
return dst;
|
||||
}
|
||||
}
|
||||
|
||||
char StringLiteralAliasing2(bool b) {
|
||||
if (b) {
|
||||
ExternalFunc();
|
||||
}
|
||||
else {
|
||||
ExternalFunc();
|
||||
}
|
||||
|
||||
const char* s = "Literal";
|
||||
return s[2];
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -4,16 +4,20 @@ test.cpp:
|
||||
# 1| v1_1(void) = EnterFunction :
|
||||
# 1| m1_2(unknown) = AliasedDefinition :
|
||||
# 1| valnum = unique
|
||||
# 1| mu1_3(unknown) = UnmodeledDefinition :
|
||||
# 1| m1_3(unknown) = InitializeNonLocal :
|
||||
# 1| valnum = unique
|
||||
# 1| r1_4(glval<int>) = VariableAddress[p0] :
|
||||
# 1| valnum = r1_4
|
||||
# 1| m1_5(int) = InitializeParameter[p0] : &:r1_4
|
||||
# 1| valnum = m1_5
|
||||
# 1| r1_6(glval<int>) = VariableAddress[p1] :
|
||||
# 1| m1_4(unknown) = Chi : total:m1_2, partial:m1_3
|
||||
# 1| valnum = unique
|
||||
# 1| mu1_5(unknown) = UnmodeledDefinition :
|
||||
# 1| valnum = unique
|
||||
# 1| r1_6(glval<int>) = VariableAddress[p0] :
|
||||
# 1| valnum = r1_6
|
||||
# 1| m1_7(int) = InitializeParameter[p1] : &:r1_6
|
||||
# 1| m1_7(int) = InitializeParameter[p0] : &:r1_6
|
||||
# 1| valnum = m1_7
|
||||
# 1| r1_8(glval<int>) = VariableAddress[p1] :
|
||||
# 1| valnum = r1_8
|
||||
# 1| m1_9(int) = InitializeParameter[p1] : &:r1_8
|
||||
# 1| valnum = m1_9
|
||||
# 2| r2_1(glval<int>) = VariableAddress[x] :
|
||||
# 2| valnum = r2_1
|
||||
# 2| m2_2(int) = Uninitialized[x] : &:r2_1
|
||||
@@ -27,13 +31,13 @@ test.cpp:
|
||||
# 3| m3_2(unsigned char) = Uninitialized[b] : &:r3_1
|
||||
# 3| valnum = unique
|
||||
# 5| r5_1(glval<int>) = VariableAddress[p0] :
|
||||
# 5| valnum = r1_4
|
||||
# 5| r5_2(int) = Load : &:r5_1, m1_5
|
||||
# 5| valnum = m1_5
|
||||
# 5| r5_3(glval<int>) = VariableAddress[p1] :
|
||||
# 5| valnum = r1_6
|
||||
# 5| r5_4(int) = Load : &:r5_3, m1_7
|
||||
# 5| r5_2(int) = Load : &:r5_1, m1_7
|
||||
# 5| valnum = m1_7
|
||||
# 5| r5_3(glval<int>) = VariableAddress[p1] :
|
||||
# 5| valnum = r1_8
|
||||
# 5| r5_4(int) = Load : &:r5_3, m1_9
|
||||
# 5| valnum = m1_9
|
||||
# 5| r5_5(int) = Add : r5_2, r5_4
|
||||
# 5| valnum = r5_5
|
||||
# 5| r5_6(glval<int>) = VariableAddress[x] :
|
||||
@@ -41,13 +45,13 @@ test.cpp:
|
||||
# 5| m5_7(int) = Store : &:r5_6, r5_5
|
||||
# 5| valnum = r5_5
|
||||
# 6| r6_1(glval<int>) = VariableAddress[p0] :
|
||||
# 6| valnum = r1_4
|
||||
# 6| r6_2(int) = Load : &:r6_1, m1_5
|
||||
# 6| valnum = m1_5
|
||||
# 6| r6_3(glval<int>) = VariableAddress[p1] :
|
||||
# 6| valnum = r1_6
|
||||
# 6| r6_4(int) = Load : &:r6_3, m1_7
|
||||
# 6| r6_2(int) = Load : &:r6_1, m1_7
|
||||
# 6| valnum = m1_7
|
||||
# 6| r6_3(glval<int>) = VariableAddress[p1] :
|
||||
# 6| valnum = r1_8
|
||||
# 6| r6_4(int) = Load : &:r6_3, m1_9
|
||||
# 6| valnum = m1_9
|
||||
# 6| r6_5(int) = Add : r6_2, r6_4
|
||||
# 6| valnum = r5_5
|
||||
# 6| r6_6(glval<int>) = VariableAddress[x] :
|
||||
@@ -63,28 +67,32 @@ test.cpp:
|
||||
# 7| m7_4(int) = Store : &:r7_3, r7_2
|
||||
# 7| valnum = r5_5
|
||||
# 8| v8_1(void) = NoOp :
|
||||
# 1| r1_8(glval<int>) = VariableAddress[#return] :
|
||||
# 1| r1_10(glval<int>) = VariableAddress[#return] :
|
||||
# 1| valnum = unique
|
||||
# 1| v1_9(void) = ReturnValue : &:r1_8
|
||||
# 1| v1_10(void) = UnmodeledUse : mu*
|
||||
# 1| v1_11(void) = AliasedUse : ~m1_2
|
||||
# 1| v1_12(void) = ExitFunction :
|
||||
# 1| v1_11(void) = ReturnValue : &:r1_10
|
||||
# 1| v1_12(void) = UnmodeledUse : mu*
|
||||
# 1| v1_13(void) = AliasedUse : m1_3
|
||||
# 1| v1_14(void) = ExitFunction :
|
||||
|
||||
# 12| int test01(int, int)
|
||||
# 12| Block 0
|
||||
# 12| v12_1(void) = EnterFunction :
|
||||
# 12| m12_2(unknown) = AliasedDefinition :
|
||||
# 12| valnum = unique
|
||||
# 12| mu12_3(unknown) = UnmodeledDefinition :
|
||||
# 12| m12_3(unknown) = InitializeNonLocal :
|
||||
# 12| valnum = unique
|
||||
# 12| r12_4(glval<int>) = VariableAddress[p0] :
|
||||
# 12| valnum = r12_4
|
||||
# 12| m12_5(int) = InitializeParameter[p0] : &:r12_4
|
||||
# 12| valnum = m12_5
|
||||
# 12| r12_6(glval<int>) = VariableAddress[p1] :
|
||||
# 12| m12_4(unknown) = Chi : total:m12_2, partial:m12_3
|
||||
# 12| valnum = unique
|
||||
# 12| mu12_5(unknown) = UnmodeledDefinition :
|
||||
# 12| valnum = unique
|
||||
# 12| r12_6(glval<int>) = VariableAddress[p0] :
|
||||
# 12| valnum = r12_6
|
||||
# 12| m12_7(int) = InitializeParameter[p1] : &:r12_6
|
||||
# 12| m12_7(int) = InitializeParameter[p0] : &:r12_6
|
||||
# 12| valnum = m12_7
|
||||
# 12| r12_8(glval<int>) = VariableAddress[p1] :
|
||||
# 12| valnum = r12_8
|
||||
# 12| m12_9(int) = InitializeParameter[p1] : &:r12_8
|
||||
# 12| valnum = m12_9
|
||||
# 13| r13_1(glval<int>) = VariableAddress[x] :
|
||||
# 13| valnum = r13_1
|
||||
# 13| m13_2(int) = Uninitialized[x] : &:r13_1
|
||||
@@ -98,18 +106,18 @@ test.cpp:
|
||||
# 14| m14_2(unsigned char) = Uninitialized[b] : &:r14_1
|
||||
# 14| valnum = unique
|
||||
# 16| r16_1(glval<int>) = VariableAddress[p0] :
|
||||
# 16| valnum = r12_4
|
||||
# 16| r16_2(int) = Load : &:r16_1, m12_5
|
||||
# 16| valnum = m12_5
|
||||
# 16| r16_3(glval<int>) = VariableAddress[p1] :
|
||||
# 16| valnum = r12_6
|
||||
# 16| r16_4(int) = Load : &:r16_3, m12_7
|
||||
# 16| r16_2(int) = Load : &:r16_1, m12_7
|
||||
# 16| valnum = m12_7
|
||||
# 16| r16_3(glval<int>) = VariableAddress[p1] :
|
||||
# 16| valnum = r12_8
|
||||
# 16| r16_4(int) = Load : &:r16_3, m12_9
|
||||
# 16| valnum = m12_9
|
||||
# 16| r16_5(int) = Add : r16_2, r16_4
|
||||
# 16| valnum = r16_5
|
||||
# 16| r16_6(glval<int>) = VariableAddress[global01] :
|
||||
# 16| valnum = r16_6
|
||||
# 16| r16_7(int) = Load : &:r16_6, ~m12_2
|
||||
# 16| r16_7(int) = Load : &:r16_6, ~m12_3
|
||||
# 16| valnum = unique
|
||||
# 16| r16_8(int) = Add : r16_5, r16_7
|
||||
# 16| valnum = r16_8
|
||||
@@ -118,18 +126,18 @@ test.cpp:
|
||||
# 16| m16_10(int) = Store : &:r16_9, r16_8
|
||||
# 16| valnum = r16_8
|
||||
# 17| r17_1(glval<int>) = VariableAddress[p0] :
|
||||
# 17| valnum = r12_4
|
||||
# 17| r17_2(int) = Load : &:r17_1, m12_5
|
||||
# 17| valnum = m12_5
|
||||
# 17| r17_3(glval<int>) = VariableAddress[p1] :
|
||||
# 17| valnum = r12_6
|
||||
# 17| r17_4(int) = Load : &:r17_3, m12_7
|
||||
# 17| r17_2(int) = Load : &:r17_1, m12_7
|
||||
# 17| valnum = m12_7
|
||||
# 17| r17_3(glval<int>) = VariableAddress[p1] :
|
||||
# 17| valnum = r12_8
|
||||
# 17| r17_4(int) = Load : &:r17_3, m12_9
|
||||
# 17| valnum = m12_9
|
||||
# 17| r17_5(int) = Add : r17_2, r17_4
|
||||
# 17| valnum = r16_5
|
||||
# 17| r17_6(glval<int>) = VariableAddress[global01] :
|
||||
# 17| valnum = r16_6
|
||||
# 17| r17_7(int) = Load : &:r17_6, ~m12_2
|
||||
# 17| r17_7(int) = Load : &:r17_6, ~m12_3
|
||||
# 17| valnum = unique
|
||||
# 17| r17_8(int) = Add : r17_5, r17_7
|
||||
# 17| valnum = r17_8
|
||||
@@ -146,28 +154,32 @@ test.cpp:
|
||||
# 18| m18_4(int) = Store : &:r18_3, r18_2
|
||||
# 18| valnum = r17_8
|
||||
# 19| v19_1(void) = NoOp :
|
||||
# 12| r12_8(glval<int>) = VariableAddress[#return] :
|
||||
# 12| r12_10(glval<int>) = VariableAddress[#return] :
|
||||
# 12| valnum = unique
|
||||
# 12| v12_9(void) = ReturnValue : &:r12_8
|
||||
# 12| v12_10(void) = UnmodeledUse : mu*
|
||||
# 12| v12_11(void) = AliasedUse : ~m12_2
|
||||
# 12| v12_12(void) = ExitFunction :
|
||||
# 12| v12_11(void) = ReturnValue : &:r12_10
|
||||
# 12| v12_12(void) = UnmodeledUse : mu*
|
||||
# 12| v12_13(void) = AliasedUse : m12_3
|
||||
# 12| v12_14(void) = ExitFunction :
|
||||
|
||||
# 25| int test02(int, int)
|
||||
# 25| Block 0
|
||||
# 25| v25_1(void) = EnterFunction :
|
||||
# 25| m25_2(unknown) = AliasedDefinition :
|
||||
# 25| valnum = unique
|
||||
# 25| mu25_3(unknown) = UnmodeledDefinition :
|
||||
# 25| m25_3(unknown) = InitializeNonLocal :
|
||||
# 25| valnum = unique
|
||||
# 25| r25_4(glval<int>) = VariableAddress[p0] :
|
||||
# 25| valnum = r25_4
|
||||
# 25| m25_5(int) = InitializeParameter[p0] : &:r25_4
|
||||
# 25| valnum = m25_5
|
||||
# 25| r25_6(glval<int>) = VariableAddress[p1] :
|
||||
# 25| m25_4(unknown) = Chi : total:m25_2, partial:m25_3
|
||||
# 25| valnum = unique
|
||||
# 25| mu25_5(unknown) = UnmodeledDefinition :
|
||||
# 25| valnum = unique
|
||||
# 25| r25_6(glval<int>) = VariableAddress[p0] :
|
||||
# 25| valnum = r25_6
|
||||
# 25| m25_7(int) = InitializeParameter[p1] : &:r25_6
|
||||
# 25| m25_7(int) = InitializeParameter[p0] : &:r25_6
|
||||
# 25| valnum = m25_7
|
||||
# 25| r25_8(glval<int>) = VariableAddress[p1] :
|
||||
# 25| valnum = r25_8
|
||||
# 25| m25_9(int) = InitializeParameter[p1] : &:r25_8
|
||||
# 25| valnum = m25_9
|
||||
# 26| r26_1(glval<int>) = VariableAddress[x] :
|
||||
# 26| valnum = r26_1
|
||||
# 26| m26_2(int) = Uninitialized[x] : &:r26_1
|
||||
@@ -181,18 +193,18 @@ test.cpp:
|
||||
# 27| m27_2(unsigned char) = Uninitialized[b] : &:r27_1
|
||||
# 27| valnum = unique
|
||||
# 29| r29_1(glval<int>) = VariableAddress[p0] :
|
||||
# 29| valnum = r25_4
|
||||
# 29| r29_2(int) = Load : &:r29_1, m25_5
|
||||
# 29| valnum = m25_5
|
||||
# 29| r29_3(glval<int>) = VariableAddress[p1] :
|
||||
# 29| valnum = r25_6
|
||||
# 29| r29_4(int) = Load : &:r29_3, m25_7
|
||||
# 29| r29_2(int) = Load : &:r29_1, m25_7
|
||||
# 29| valnum = m25_7
|
||||
# 29| r29_3(glval<int>) = VariableAddress[p1] :
|
||||
# 29| valnum = r25_8
|
||||
# 29| r29_4(int) = Load : &:r29_3, m25_9
|
||||
# 29| valnum = m25_9
|
||||
# 29| r29_5(int) = Add : r29_2, r29_4
|
||||
# 29| valnum = r29_5
|
||||
# 29| r29_6(glval<int>) = VariableAddress[global02] :
|
||||
# 29| valnum = r29_6
|
||||
# 29| r29_7(int) = Load : &:r29_6, ~m25_2
|
||||
# 29| r29_7(int) = Load : &:r29_6, ~m25_3
|
||||
# 29| valnum = unique
|
||||
# 29| r29_8(int) = Add : r29_5, r29_7
|
||||
# 29| valnum = r29_8
|
||||
@@ -203,18 +215,18 @@ test.cpp:
|
||||
# 30| r30_1(glval<unknown>) = FunctionAddress[change_global02] :
|
||||
# 30| valnum = unique
|
||||
# 30| v30_2(void) = Call : func:r30_1
|
||||
# 30| m30_3(unknown) = ^CallSideEffect : ~m25_2
|
||||
# 30| m30_3(unknown) = ^CallSideEffect : ~m25_4
|
||||
# 30| valnum = unique
|
||||
# 30| m30_4(unknown) = Chi : total:m25_2, partial:m30_3
|
||||
# 30| m30_4(unknown) = Chi : total:m25_4, partial:m30_3
|
||||
# 30| valnum = unique
|
||||
# 31| r31_1(glval<int>) = VariableAddress[p0] :
|
||||
# 31| valnum = r25_4
|
||||
# 31| r31_2(int) = Load : &:r31_1, m25_5
|
||||
# 31| valnum = m25_5
|
||||
# 31| r31_3(glval<int>) = VariableAddress[p1] :
|
||||
# 31| valnum = r25_6
|
||||
# 31| r31_4(int) = Load : &:r31_3, m25_7
|
||||
# 31| r31_2(int) = Load : &:r31_1, m25_7
|
||||
# 31| valnum = m25_7
|
||||
# 31| r31_3(glval<int>) = VariableAddress[p1] :
|
||||
# 31| valnum = r25_8
|
||||
# 31| r31_4(int) = Load : &:r31_3, m25_9
|
||||
# 31| valnum = m25_9
|
||||
# 31| r31_5(int) = Add : r31_2, r31_4
|
||||
# 31| valnum = r29_5
|
||||
# 31| r31_6(glval<int>) = VariableAddress[global02] :
|
||||
@@ -236,35 +248,39 @@ test.cpp:
|
||||
# 32| m32_4(int) = Store : &:r32_3, r32_2
|
||||
# 32| valnum = r31_8
|
||||
# 33| v33_1(void) = NoOp :
|
||||
# 25| r25_8(glval<int>) = VariableAddress[#return] :
|
||||
# 25| r25_10(glval<int>) = VariableAddress[#return] :
|
||||
# 25| valnum = unique
|
||||
# 25| v25_9(void) = ReturnValue : &:r25_8
|
||||
# 25| v25_10(void) = UnmodeledUse : mu*
|
||||
# 25| v25_11(void) = AliasedUse : ~m30_4
|
||||
# 25| v25_12(void) = ExitFunction :
|
||||
# 25| v25_11(void) = ReturnValue : &:r25_10
|
||||
# 25| v25_12(void) = UnmodeledUse : mu*
|
||||
# 25| v25_13(void) = AliasedUse : ~m30_4
|
||||
# 25| v25_14(void) = ExitFunction :
|
||||
|
||||
# 39| int test03(int, int, int*)
|
||||
# 39| Block 0
|
||||
# 39| v39_1(void) = EnterFunction :
|
||||
# 39| m39_2(unknown) = AliasedDefinition :
|
||||
# 39| valnum = unique
|
||||
# 39| mu39_3(unknown) = UnmodeledDefinition :
|
||||
# 39| m39_3(unknown) = InitializeNonLocal :
|
||||
# 39| valnum = unique
|
||||
# 39| r39_4(glval<int>) = VariableAddress[p0] :
|
||||
# 39| valnum = r39_4
|
||||
# 39| m39_5(int) = InitializeParameter[p0] : &:r39_4
|
||||
# 39| valnum = m39_5
|
||||
# 39| r39_6(glval<int>) = VariableAddress[p1] :
|
||||
# 39| m39_4(unknown) = Chi : total:m39_2, partial:m39_3
|
||||
# 39| valnum = unique
|
||||
# 39| mu39_5(unknown) = UnmodeledDefinition :
|
||||
# 39| valnum = unique
|
||||
# 39| r39_6(glval<int>) = VariableAddress[p0] :
|
||||
# 39| valnum = r39_6
|
||||
# 39| m39_7(int) = InitializeParameter[p1] : &:r39_6
|
||||
# 39| m39_7(int) = InitializeParameter[p0] : &:r39_6
|
||||
# 39| valnum = m39_7
|
||||
# 39| r39_8(glval<int *>) = VariableAddress[p2] :
|
||||
# 39| r39_8(glval<int>) = VariableAddress[p1] :
|
||||
# 39| valnum = r39_8
|
||||
# 39| m39_9(int *) = InitializeParameter[p2] : &:r39_8
|
||||
# 39| m39_9(int) = InitializeParameter[p1] : &:r39_8
|
||||
# 39| valnum = m39_9
|
||||
# 39| r39_10(int *) = Load : &:r39_8, m39_9
|
||||
# 39| valnum = m39_9
|
||||
# 39| m39_11(unknown) = InitializeIndirection[p2] : &:r39_10
|
||||
# 39| r39_10(glval<int *>) = VariableAddress[p2] :
|
||||
# 39| valnum = r39_10
|
||||
# 39| m39_11(int *) = InitializeParameter[p2] : &:r39_10
|
||||
# 39| valnum = m39_11
|
||||
# 39| r39_12(int *) = Load : &:r39_10, m39_11
|
||||
# 39| valnum = m39_11
|
||||
# 39| m39_13(unknown) = InitializeIndirection[p2] : &:r39_12
|
||||
# 39| valnum = unique
|
||||
# 40| r40_1(glval<int>) = VariableAddress[x] :
|
||||
# 40| valnum = r40_1
|
||||
@@ -279,18 +295,18 @@ test.cpp:
|
||||
# 41| m41_2(unsigned char) = Uninitialized[b] : &:r41_1
|
||||
# 41| valnum = unique
|
||||
# 43| r43_1(glval<int>) = VariableAddress[p0] :
|
||||
# 43| valnum = r39_4
|
||||
# 43| r43_2(int) = Load : &:r43_1, m39_5
|
||||
# 43| valnum = m39_5
|
||||
# 43| r43_3(glval<int>) = VariableAddress[p1] :
|
||||
# 43| valnum = r39_6
|
||||
# 43| r43_4(int) = Load : &:r43_3, m39_7
|
||||
# 43| r43_2(int) = Load : &:r43_1, m39_7
|
||||
# 43| valnum = m39_7
|
||||
# 43| r43_3(glval<int>) = VariableAddress[p1] :
|
||||
# 43| valnum = r39_8
|
||||
# 43| r43_4(int) = Load : &:r43_3, m39_9
|
||||
# 43| valnum = m39_9
|
||||
# 43| r43_5(int) = Add : r43_2, r43_4
|
||||
# 43| valnum = r43_5
|
||||
# 43| r43_6(glval<int>) = VariableAddress[global03] :
|
||||
# 43| valnum = r43_6
|
||||
# 43| r43_7(int) = Load : &:r43_6, ~m39_2
|
||||
# 43| r43_7(int) = Load : &:r43_6, ~m39_3
|
||||
# 43| valnum = unique
|
||||
# 43| r43_8(int) = Add : r43_5, r43_7
|
||||
# 43| valnum = r43_8
|
||||
@@ -301,28 +317,28 @@ test.cpp:
|
||||
# 44| r44_1(int) = Constant[0] :
|
||||
# 44| valnum = r44_1
|
||||
# 44| r44_2(glval<int *>) = VariableAddress[p2] :
|
||||
# 44| valnum = r39_8
|
||||
# 44| r44_3(int *) = Load : &:r44_2, m39_9
|
||||
# 44| valnum = m39_9
|
||||
# 44| valnum = r39_10
|
||||
# 44| r44_3(int *) = Load : &:r44_2, m39_11
|
||||
# 44| valnum = m39_11
|
||||
# 44| r44_4(glval<int>) = CopyValue : r44_3
|
||||
# 44| valnum = m39_9
|
||||
# 44| valnum = m39_11
|
||||
# 44| m44_5(int) = Store : &:r44_4, r44_1
|
||||
# 44| valnum = r44_1
|
||||
# 44| m44_6(unknown) = Chi : total:m39_11, partial:m44_5
|
||||
# 44| m44_6(unknown) = Chi : total:m39_13, partial:m44_5
|
||||
# 44| valnum = unique
|
||||
# 45| r45_1(glval<int>) = VariableAddress[p0] :
|
||||
# 45| valnum = r39_4
|
||||
# 45| r45_2(int) = Load : &:r45_1, m39_5
|
||||
# 45| valnum = m39_5
|
||||
# 45| r45_3(glval<int>) = VariableAddress[p1] :
|
||||
# 45| valnum = r39_6
|
||||
# 45| r45_4(int) = Load : &:r45_3, m39_7
|
||||
# 45| r45_2(int) = Load : &:r45_1, m39_7
|
||||
# 45| valnum = m39_7
|
||||
# 45| r45_3(glval<int>) = VariableAddress[p1] :
|
||||
# 45| valnum = r39_8
|
||||
# 45| r45_4(int) = Load : &:r45_3, m39_9
|
||||
# 45| valnum = m39_9
|
||||
# 45| r45_5(int) = Add : r45_2, r45_4
|
||||
# 45| valnum = r43_5
|
||||
# 45| r45_6(glval<int>) = VariableAddress[global03] :
|
||||
# 45| valnum = r43_6
|
||||
# 45| r45_7(int) = Load : &:r45_6, ~m39_2
|
||||
# 45| r45_7(int) = Load : &:r45_6, ~m39_3
|
||||
# 45| valnum = unique
|
||||
# 45| r45_8(int) = Add : r45_5, r45_7
|
||||
# 45| valnum = r45_8
|
||||
@@ -339,36 +355,40 @@ test.cpp:
|
||||
# 46| m46_4(int) = Store : &:r46_3, r46_2
|
||||
# 46| valnum = r45_8
|
||||
# 47| v47_1(void) = NoOp :
|
||||
# 39| v39_12(void) = ReturnIndirection : &:r39_10, ~m44_6
|
||||
# 39| r39_13(glval<int>) = VariableAddress[#return] :
|
||||
# 39| v39_14(void) = ReturnIndirection : &:r39_12, ~m44_6
|
||||
# 39| r39_15(glval<int>) = VariableAddress[#return] :
|
||||
# 39| valnum = unique
|
||||
# 39| v39_14(void) = ReturnValue : &:r39_13
|
||||
# 39| v39_15(void) = UnmodeledUse : mu*
|
||||
# 39| v39_16(void) = AliasedUse : ~m39_2
|
||||
# 39| v39_17(void) = ExitFunction :
|
||||
# 39| v39_16(void) = ReturnValue : &:r39_15
|
||||
# 39| v39_17(void) = UnmodeledUse : mu*
|
||||
# 39| v39_18(void) = AliasedUse : m39_3
|
||||
# 39| v39_19(void) = ExitFunction :
|
||||
|
||||
# 49| unsigned int my_strspn(char const*, char const*)
|
||||
# 49| Block 0
|
||||
# 49| v49_1(void) = EnterFunction :
|
||||
# 49| m49_2(unknown) = AliasedDefinition :
|
||||
# 49| valnum = unique
|
||||
# 49| mu49_3(unknown) = UnmodeledDefinition :
|
||||
# 49| m49_3(unknown) = InitializeNonLocal :
|
||||
# 49| valnum = unique
|
||||
# 49| r49_4(glval<char *>) = VariableAddress[str] :
|
||||
# 49| valnum = r49_4
|
||||
# 49| m49_5(char *) = InitializeParameter[str] : &:r49_4
|
||||
# 49| valnum = m49_5
|
||||
# 49| r49_6(char *) = Load : &:r49_4, m49_5
|
||||
# 49| valnum = m49_5
|
||||
# 49| m49_7(unknown) = InitializeIndirection[str] : &:r49_6
|
||||
# 49| m49_4(unknown) = Chi : total:m49_2, partial:m49_3
|
||||
# 49| valnum = unique
|
||||
# 49| r49_8(glval<char *>) = VariableAddress[chars] :
|
||||
# 49| valnum = r49_8
|
||||
# 49| m49_9(char *) = InitializeParameter[chars] : &:r49_8
|
||||
# 49| valnum = m49_9
|
||||
# 49| r49_10(char *) = Load : &:r49_8, m49_9
|
||||
# 49| valnum = m49_9
|
||||
# 49| m49_11(unknown) = InitializeIndirection[chars] : &:r49_10
|
||||
# 49| mu49_5(unknown) = UnmodeledDefinition :
|
||||
# 49| valnum = unique
|
||||
# 49| r49_6(glval<char *>) = VariableAddress[str] :
|
||||
# 49| valnum = r49_6
|
||||
# 49| m49_7(char *) = InitializeParameter[str] : &:r49_6
|
||||
# 49| valnum = m49_7
|
||||
# 49| r49_8(char *) = Load : &:r49_6, m49_7
|
||||
# 49| valnum = m49_7
|
||||
# 49| m49_9(unknown) = InitializeIndirection[str] : &:r49_8
|
||||
# 49| valnum = unique
|
||||
# 49| r49_10(glval<char *>) = VariableAddress[chars] :
|
||||
# 49| valnum = r49_10
|
||||
# 49| m49_11(char *) = InitializeParameter[chars] : &:r49_10
|
||||
# 49| valnum = m49_11
|
||||
# 49| r49_12(char *) = Load : &:r49_10, m49_11
|
||||
# 49| valnum = m49_11
|
||||
# 49| m49_13(unknown) = InitializeIndirection[chars] : &:r49_12
|
||||
# 49| valnum = unique
|
||||
# 50| r50_1(glval<char *>) = VariableAddress[ptr] :
|
||||
# 50| valnum = r50_1
|
||||
@@ -386,10 +406,10 @@ test.cpp:
|
||||
# 53| m53_1(unsigned int) = Phi : from 0:m51_3, from 8:m62_5
|
||||
# 53| valnum = m53_1
|
||||
# 53| r53_2(glval<char *>) = VariableAddress[str] :
|
||||
# 53| valnum = r49_4
|
||||
# 53| r53_3(char *) = Load : &:r53_2, m49_5
|
||||
# 53| valnum = m49_5
|
||||
# 53| r53_4(char) = Load : &:r53_3, ~m49_7
|
||||
# 53| valnum = r49_6
|
||||
# 53| r53_3(char *) = Load : &:r53_2, m49_7
|
||||
# 53| valnum = m49_7
|
||||
# 53| r53_4(char) = Load : &:r53_3, ~m49_9
|
||||
# 53| valnum = unique
|
||||
# 53| r53_5(int) = Convert : r53_4
|
||||
# 53| valnum = unique
|
||||
@@ -403,13 +423,13 @@ test.cpp:
|
||||
|
||||
# 55| Block 2
|
||||
# 55| r55_1(glval<char *>) = VariableAddress[chars] :
|
||||
# 55| valnum = r49_8
|
||||
# 55| r55_2(char *) = Load : &:r55_1, m49_9
|
||||
# 55| valnum = m49_9
|
||||
# 55| valnum = r49_10
|
||||
# 55| r55_2(char *) = Load : &:r55_1, m49_11
|
||||
# 55| valnum = m49_11
|
||||
# 55| r55_3(glval<char *>) = VariableAddress[ptr] :
|
||||
# 55| valnum = r50_1
|
||||
# 55| m55_4(char *) = Store : &:r55_3, r55_2
|
||||
# 55| valnum = m49_9
|
||||
# 55| valnum = m49_11
|
||||
#-----| Goto -> Block 3
|
||||
|
||||
# 56| Block 3
|
||||
@@ -419,15 +439,15 @@ test.cpp:
|
||||
# 56| valnum = r50_1
|
||||
# 56| r56_3(char *) = Load : &:r56_2, m56_1
|
||||
# 56| valnum = m56_1
|
||||
# 56| r56_4(char) = Load : &:r56_3, ~m49_2
|
||||
# 56| r56_4(char) = Load : &:r56_3, ~m49_4
|
||||
# 56| valnum = unique
|
||||
# 56| r56_5(int) = Convert : r56_4
|
||||
# 56| valnum = unique
|
||||
# 56| r56_6(glval<char *>) = VariableAddress[str] :
|
||||
# 56| valnum = r49_4
|
||||
# 56| r56_7(char *) = Load : &:r56_6, m49_5
|
||||
# 56| valnum = m49_5
|
||||
# 56| r56_8(char) = Load : &:r56_7, ~m49_7
|
||||
# 56| valnum = r49_6
|
||||
# 56| r56_7(char *) = Load : &:r56_6, m49_7
|
||||
# 56| valnum = m49_7
|
||||
# 56| r56_8(char) = Load : &:r56_7, ~m49_9
|
||||
# 56| valnum = unique
|
||||
# 56| r56_9(int) = Convert : r56_8
|
||||
# 56| valnum = unique
|
||||
@@ -442,7 +462,7 @@ test.cpp:
|
||||
# 56| valnum = r50_1
|
||||
# 56| r56_13(char *) = Load : &:r56_12, m56_1
|
||||
# 56| valnum = m56_1
|
||||
# 56| r56_14(char) = Load : &:r56_13, ~m49_2
|
||||
# 56| r56_14(char) = Load : &:r56_13, ~m49_4
|
||||
# 56| valnum = unique
|
||||
# 56| r56_15(int) = Convert : r56_14
|
||||
# 56| valnum = unique
|
||||
@@ -472,7 +492,7 @@ test.cpp:
|
||||
# 59| valnum = r50_1
|
||||
# 59| r59_2(char *) = Load : &:r59_1, m56_1
|
||||
# 59| valnum = m56_1
|
||||
# 59| r59_3(char) = Load : &:r59_2, ~m49_2
|
||||
# 59| r59_3(char) = Load : &:r59_2, ~m49_4
|
||||
# 59| valnum = unique
|
||||
# 59| r59_4(int) = Convert : r59_3
|
||||
# 59| valnum = unique
|
||||
@@ -511,29 +531,33 @@ test.cpp:
|
||||
# 65| valnum = m53_1
|
||||
# 65| m65_4(unsigned int) = Store : &:r65_1, r65_3
|
||||
# 65| valnum = m53_1
|
||||
# 49| v49_12(void) = ReturnIndirection : &:r49_6, m49_7
|
||||
# 49| v49_13(void) = ReturnIndirection : &:r49_10, m49_11
|
||||
# 49| r49_14(glval<unsigned int>) = VariableAddress[#return] :
|
||||
# 49| v49_14(void) = ReturnIndirection : &:r49_8, m49_9
|
||||
# 49| v49_15(void) = ReturnIndirection : &:r49_12, m49_13
|
||||
# 49| r49_16(glval<unsigned int>) = VariableAddress[#return] :
|
||||
# 49| valnum = r65_1
|
||||
# 49| v49_15(void) = ReturnValue : &:r49_14, m65_4
|
||||
# 49| v49_16(void) = UnmodeledUse : mu*
|
||||
# 49| v49_17(void) = AliasedUse : ~m49_2
|
||||
# 49| v49_18(void) = ExitFunction :
|
||||
# 49| v49_17(void) = ReturnValue : &:r49_16, m65_4
|
||||
# 49| v49_18(void) = UnmodeledUse : mu*
|
||||
# 49| v49_19(void) = AliasedUse : m49_3
|
||||
# 49| v49_20(void) = ExitFunction :
|
||||
|
||||
# 75| void test04(two_values*)
|
||||
# 75| Block 0
|
||||
# 75| v75_1(void) = EnterFunction :
|
||||
# 75| m75_2(unknown) = AliasedDefinition :
|
||||
# 75| valnum = unique
|
||||
# 75| mu75_3(unknown) = UnmodeledDefinition :
|
||||
# 75| m75_3(unknown) = InitializeNonLocal :
|
||||
# 75| valnum = unique
|
||||
# 75| r75_4(glval<two_values *>) = VariableAddress[vals] :
|
||||
# 75| valnum = r75_4
|
||||
# 75| m75_5(two_values *) = InitializeParameter[vals] : &:r75_4
|
||||
# 75| valnum = m75_5
|
||||
# 75| r75_6(two_values *) = Load : &:r75_4, m75_5
|
||||
# 75| valnum = m75_5
|
||||
# 75| m75_7(unknown) = InitializeIndirection[vals] : &:r75_6
|
||||
# 75| m75_4(unknown) = Chi : total:m75_2, partial:m75_3
|
||||
# 75| valnum = unique
|
||||
# 75| mu75_5(unknown) = UnmodeledDefinition :
|
||||
# 75| valnum = unique
|
||||
# 75| r75_6(glval<two_values *>) = VariableAddress[vals] :
|
||||
# 75| valnum = r75_6
|
||||
# 75| m75_7(two_values *) = InitializeParameter[vals] : &:r75_6
|
||||
# 75| valnum = m75_7
|
||||
# 75| r75_8(two_values *) = Load : &:r75_6, m75_7
|
||||
# 75| valnum = m75_7
|
||||
# 75| m75_9(unknown) = InitializeIndirection[vals] : &:r75_8
|
||||
# 75| valnum = unique
|
||||
# 77| r77_1(glval<signed short>) = VariableAddress[v] :
|
||||
# 77| valnum = r77_1
|
||||
@@ -541,9 +565,9 @@ test.cpp:
|
||||
# 77| valnum = unique
|
||||
# 77| r77_3(int) = Call : func:r77_2
|
||||
# 77| valnum = unique
|
||||
# 77| m77_4(unknown) = ^CallSideEffect : ~m75_2
|
||||
# 77| m77_4(unknown) = ^CallSideEffect : ~m75_4
|
||||
# 77| valnum = unique
|
||||
# 77| m77_5(unknown) = Chi : total:m75_2, partial:m77_4
|
||||
# 77| m77_5(unknown) = Chi : total:m75_4, partial:m77_4
|
||||
# 77| valnum = unique
|
||||
# 77| r77_6(signed short) = Convert : r77_3
|
||||
# 77| valnum = r77_6
|
||||
@@ -556,22 +580,22 @@ test.cpp:
|
||||
# 79| r79_3(int) = Convert : r79_2
|
||||
# 79| valnum = unique
|
||||
# 79| r79_4(glval<two_values *>) = VariableAddress[vals] :
|
||||
# 79| valnum = r75_4
|
||||
# 79| r79_5(two_values *) = Load : &:r79_4, m75_5
|
||||
# 79| valnum = m75_5
|
||||
# 79| valnum = r75_6
|
||||
# 79| r79_5(two_values *) = Load : &:r79_4, m75_7
|
||||
# 79| valnum = m75_7
|
||||
# 79| r79_6(glval<signed short>) = FieldAddress[val1] : r79_5
|
||||
# 79| valnum = unique
|
||||
# 79| r79_7(signed short) = Load : &:r79_6, ~m75_7
|
||||
# 79| r79_7(signed short) = Load : &:r79_6, ~m75_9
|
||||
# 79| valnum = unique
|
||||
# 79| r79_8(int) = Convert : r79_7
|
||||
# 79| valnum = unique
|
||||
# 79| r79_9(glval<two_values *>) = VariableAddress[vals] :
|
||||
# 79| valnum = r75_4
|
||||
# 79| r79_10(two_values *) = Load : &:r79_9, m75_5
|
||||
# 79| valnum = m75_5
|
||||
# 79| valnum = r75_6
|
||||
# 79| r79_10(two_values *) = Load : &:r79_9, m75_7
|
||||
# 79| valnum = m75_7
|
||||
# 79| r79_11(glval<signed short>) = FieldAddress[val2] : r79_10
|
||||
# 79| valnum = unique
|
||||
# 79| r79_12(signed short) = Load : &:r79_11, ~m75_7
|
||||
# 79| r79_12(signed short) = Load : &:r79_11, ~m75_9
|
||||
# 79| valnum = unique
|
||||
# 79| r79_13(int) = Convert : r79_12
|
||||
# 79| valnum = unique
|
||||
@@ -604,48 +628,52 @@ test.cpp:
|
||||
# 82| m82_1(unknown) = Phi : from 0:~m77_5, from 1:~m80_4
|
||||
# 82| valnum = unique
|
||||
# 82| v82_2(void) = NoOp :
|
||||
# 75| v75_8(void) = ReturnIndirection : &:r75_6, m75_7
|
||||
# 75| v75_9(void) = ReturnVoid :
|
||||
# 75| v75_10(void) = UnmodeledUse : mu*
|
||||
# 75| v75_11(void) = AliasedUse : ~m82_1
|
||||
# 75| v75_12(void) = ExitFunction :
|
||||
# 75| v75_10(void) = ReturnIndirection : &:r75_8, m75_9
|
||||
# 75| v75_11(void) = ReturnVoid :
|
||||
# 75| v75_12(void) = UnmodeledUse : mu*
|
||||
# 75| v75_13(void) = AliasedUse : ~m82_1
|
||||
# 75| v75_14(void) = ExitFunction :
|
||||
|
||||
# 84| void test05(int, int, void*)
|
||||
# 84| Block 0
|
||||
# 84| v84_1(void) = EnterFunction :
|
||||
# 84| m84_2(unknown) = AliasedDefinition :
|
||||
# 84| v84_1(void) = EnterFunction :
|
||||
# 84| m84_2(unknown) = AliasedDefinition :
|
||||
# 84| valnum = unique
|
||||
# 84| mu84_3(unknown) = UnmodeledDefinition :
|
||||
# 84| m84_3(unknown) = InitializeNonLocal :
|
||||
# 84| valnum = unique
|
||||
# 84| r84_4(glval<int>) = VariableAddress[x] :
|
||||
# 84| valnum = r84_4
|
||||
# 84| m84_5(int) = InitializeParameter[x] : &:r84_4
|
||||
# 84| valnum = m84_5
|
||||
# 84| r84_6(glval<int>) = VariableAddress[y] :
|
||||
# 84| m84_4(unknown) = Chi : total:m84_2, partial:m84_3
|
||||
# 84| valnum = unique
|
||||
# 84| mu84_5(unknown) = UnmodeledDefinition :
|
||||
# 84| valnum = unique
|
||||
# 84| r84_6(glval<int>) = VariableAddress[x] :
|
||||
# 84| valnum = r84_6
|
||||
# 84| m84_7(int) = InitializeParameter[y] : &:r84_6
|
||||
# 84| m84_7(int) = InitializeParameter[x] : &:r84_6
|
||||
# 84| valnum = m84_7
|
||||
# 84| r84_8(glval<void *>) = VariableAddress[p] :
|
||||
# 84| r84_8(glval<int>) = VariableAddress[y] :
|
||||
# 84| valnum = r84_8
|
||||
# 84| m84_9(void *) = InitializeParameter[p] : &:r84_8
|
||||
# 84| m84_9(int) = InitializeParameter[y] : &:r84_8
|
||||
# 84| valnum = m84_9
|
||||
# 84| r84_10(void *) = Load : &:r84_8, m84_9
|
||||
# 84| valnum = m84_9
|
||||
# 84| m84_11(unknown) = InitializeIndirection[p] : &:r84_10
|
||||
# 84| r84_10(glval<void *>) = VariableAddress[p] :
|
||||
# 84| valnum = r84_10
|
||||
# 84| m84_11(void *) = InitializeParameter[p] : &:r84_10
|
||||
# 84| valnum = m84_11
|
||||
# 84| r84_12(void *) = Load : &:r84_10, m84_11
|
||||
# 84| valnum = m84_11
|
||||
# 84| m84_13(unknown) = InitializeIndirection[p] : &:r84_12
|
||||
# 84| valnum = unique
|
||||
# 86| r86_1(glval<int>) = VariableAddress[v] :
|
||||
# 86| r86_1(glval<int>) = VariableAddress[v] :
|
||||
# 86| valnum = r86_1
|
||||
# 86| m86_2(int) = Uninitialized[v] : &:r86_1
|
||||
# 86| m86_2(int) = Uninitialized[v] : &:r86_1
|
||||
# 86| valnum = unique
|
||||
# 88| r88_1(glval<void *>) = VariableAddress[p] :
|
||||
# 88| valnum = r84_8
|
||||
# 88| r88_2(void *) = Load : &:r88_1, m84_9
|
||||
# 88| valnum = m84_9
|
||||
# 88| r88_3(void *) = Constant[0] :
|
||||
# 88| r88_1(glval<void *>) = VariableAddress[p] :
|
||||
# 88| valnum = r84_10
|
||||
# 88| r88_2(void *) = Load : &:r88_1, m84_11
|
||||
# 88| valnum = m84_11
|
||||
# 88| r88_3(void *) = Constant[0] :
|
||||
# 88| valnum = unique
|
||||
# 88| r88_4(bool) = CompareNE : r88_2, r88_3
|
||||
# 88| r88_4(bool) = CompareNE : r88_2, r88_3
|
||||
# 88| valnum = unique
|
||||
# 88| v88_5(void) = ConditionalBranch : r88_4
|
||||
# 88| v88_5(void) = ConditionalBranch : r88_4
|
||||
#-----| False -> Block 3
|
||||
#-----| True -> Block 2
|
||||
|
||||
@@ -661,32 +689,32 @@ test.cpp:
|
||||
# 88| m88_10(int) = Store : &:r88_9, r88_8
|
||||
# 88| valnum = m88_6
|
||||
# 89| v89_1(void) = NoOp :
|
||||
# 84| v84_12(void) = ReturnIndirection : &:r84_10, m84_11
|
||||
# 84| v84_13(void) = ReturnVoid :
|
||||
# 84| v84_14(void) = UnmodeledUse : mu*
|
||||
# 84| v84_15(void) = AliasedUse : ~m84_2
|
||||
# 84| v84_16(void) = ExitFunction :
|
||||
# 84| v84_14(void) = ReturnIndirection : &:r84_12, m84_13
|
||||
# 84| v84_15(void) = ReturnVoid :
|
||||
# 84| v84_16(void) = UnmodeledUse : mu*
|
||||
# 84| v84_17(void) = AliasedUse : m84_3
|
||||
# 84| v84_18(void) = ExitFunction :
|
||||
|
||||
# 88| Block 2
|
||||
# 88| r88_11(glval<int>) = VariableAddress[x] :
|
||||
# 88| valnum = r84_4
|
||||
# 88| r88_12(int) = Load : &:r88_11, m84_5
|
||||
# 88| valnum = m84_5
|
||||
# 88| valnum = r84_6
|
||||
# 88| r88_12(int) = Load : &:r88_11, m84_7
|
||||
# 88| valnum = m84_7
|
||||
# 88| r88_13(glval<int>) = VariableAddress[#temp88:7] :
|
||||
# 88| valnum = r88_7
|
||||
# 88| m88_14(int) = Store : &:r88_13, r88_12
|
||||
# 88| valnum = m84_5
|
||||
# 88| valnum = m84_7
|
||||
#-----| Goto -> Block 1
|
||||
|
||||
# 88| Block 3
|
||||
# 88| r88_15(glval<int>) = VariableAddress[y] :
|
||||
# 88| valnum = r84_6
|
||||
# 88| r88_16(int) = Load : &:r88_15, m84_7
|
||||
# 88| valnum = m84_7
|
||||
# 88| valnum = r84_8
|
||||
# 88| r88_16(int) = Load : &:r88_15, m84_9
|
||||
# 88| valnum = m84_9
|
||||
# 88| r88_17(glval<int>) = VariableAddress[#temp88:7] :
|
||||
# 88| valnum = r88_7
|
||||
# 88| m88_18(int) = Store : &:r88_17, r88_16
|
||||
# 88| valnum = m84_7
|
||||
# 88| valnum = m84_9
|
||||
#-----| Goto -> Block 1
|
||||
|
||||
# 91| int regression_test00()
|
||||
@@ -694,7 +722,11 @@ test.cpp:
|
||||
# 91| v91_1(void) = EnterFunction :
|
||||
# 91| m91_2(unknown) = AliasedDefinition :
|
||||
# 91| valnum = unique
|
||||
# 91| mu91_3(unknown) = UnmodeledDefinition :
|
||||
# 91| m91_3(unknown) = InitializeNonLocal :
|
||||
# 91| valnum = unique
|
||||
# 91| m91_4(unknown) = Chi : total:m91_2, partial:m91_3
|
||||
# 91| valnum = unique
|
||||
# 91| mu91_5(unknown) = UnmodeledDefinition :
|
||||
# 91| valnum = unique
|
||||
# 92| r92_1(glval<int>) = VariableAddress[x] :
|
||||
# 92| valnum = r92_1
|
||||
@@ -716,48 +748,52 @@ test.cpp:
|
||||
# 93| valnum = r92_2
|
||||
# 93| m93_4(int) = Store : &:r93_1, r93_3
|
||||
# 93| valnum = r92_2
|
||||
# 91| r91_4(glval<int>) = VariableAddress[#return] :
|
||||
# 91| r91_6(glval<int>) = VariableAddress[#return] :
|
||||
# 91| valnum = r93_1
|
||||
# 91| v91_5(void) = ReturnValue : &:r91_4, m93_4
|
||||
# 91| v91_6(void) = UnmodeledUse : mu*
|
||||
# 91| v91_7(void) = AliasedUse : ~m91_2
|
||||
# 91| v91_8(void) = ExitFunction :
|
||||
# 91| v91_7(void) = ReturnValue : &:r91_6, m93_4
|
||||
# 91| v91_8(void) = UnmodeledUse : mu*
|
||||
# 91| v91_9(void) = AliasedUse : m91_3
|
||||
# 91| v91_10(void) = ExitFunction :
|
||||
|
||||
# 104| int inheritanceConversions(Derived*)
|
||||
# 104| Block 0
|
||||
# 104| v104_1(void) = EnterFunction :
|
||||
# 104| m104_2(unknown) = AliasedDefinition :
|
||||
# 104| valnum = unique
|
||||
# 104| mu104_3(unknown) = UnmodeledDefinition :
|
||||
# 104| m104_3(unknown) = InitializeNonLocal :
|
||||
# 104| valnum = unique
|
||||
# 104| r104_4(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 104| valnum = r104_4
|
||||
# 104| m104_5(Derived *) = InitializeParameter[pd] : &:r104_4
|
||||
# 104| valnum = m104_5
|
||||
# 104| r104_6(Derived *) = Load : &:r104_4, m104_5
|
||||
# 104| valnum = m104_5
|
||||
# 104| m104_7(unknown) = InitializeIndirection[pd] : &:r104_6
|
||||
# 104| m104_4(unknown) = Chi : total:m104_2, partial:m104_3
|
||||
# 104| valnum = unique
|
||||
# 104| mu104_5(unknown) = UnmodeledDefinition :
|
||||
# 104| valnum = unique
|
||||
# 104| r104_6(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 104| valnum = r104_6
|
||||
# 104| m104_7(Derived *) = InitializeParameter[pd] : &:r104_6
|
||||
# 104| valnum = m104_7
|
||||
# 104| r104_8(Derived *) = Load : &:r104_6, m104_7
|
||||
# 104| valnum = m104_7
|
||||
# 104| m104_9(unknown) = InitializeIndirection[pd] : &:r104_8
|
||||
# 104| valnum = unique
|
||||
# 105| r105_1(glval<int>) = VariableAddress[x] :
|
||||
# 105| valnum = unique
|
||||
# 105| r105_2(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 105| valnum = r104_4
|
||||
# 105| r105_3(Derived *) = Load : &:r105_2, m104_5
|
||||
# 105| valnum = m104_5
|
||||
# 105| valnum = r104_6
|
||||
# 105| r105_3(Derived *) = Load : &:r105_2, m104_7
|
||||
# 105| valnum = m104_7
|
||||
# 105| r105_4(Base *) = ConvertToNonVirtualBase[Derived : Base] : r105_3
|
||||
# 105| valnum = r105_4
|
||||
# 105| r105_5(glval<int>) = FieldAddress[b] : r105_4
|
||||
# 105| valnum = r105_5
|
||||
# 105| r105_6(int) = Load : &:r105_5, ~m104_7
|
||||
# 105| r105_6(int) = Load : &:r105_5, ~m104_9
|
||||
# 105| valnum = r105_6
|
||||
# 105| m105_7(int) = Store : &:r105_1, r105_6
|
||||
# 105| valnum = r105_6
|
||||
# 106| r106_1(glval<Base *>) = VariableAddress[pb] :
|
||||
# 106| valnum = r106_1
|
||||
# 106| r106_2(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 106| valnum = r104_4
|
||||
# 106| r106_3(Derived *) = Load : &:r106_2, m104_5
|
||||
# 106| valnum = m104_5
|
||||
# 106| valnum = r104_6
|
||||
# 106| r106_3(Derived *) = Load : &:r106_2, m104_7
|
||||
# 106| valnum = m104_7
|
||||
# 106| r106_4(Base *) = ConvertToNonVirtualBase[Derived : Base] : r106_3
|
||||
# 106| valnum = r105_4
|
||||
# 106| m106_5(Base *) = Store : &:r106_1, r106_4
|
||||
@@ -770,7 +806,7 @@ test.cpp:
|
||||
# 107| valnum = r105_4
|
||||
# 107| r107_4(glval<int>) = FieldAddress[b] : r107_3
|
||||
# 107| valnum = r105_5
|
||||
# 107| r107_5(int) = Load : &:r107_4, ~m104_7
|
||||
# 107| r107_5(int) = Load : &:r107_4, ~m104_9
|
||||
# 107| valnum = r107_5
|
||||
# 107| m107_6(int) = Store : &:r107_1, r107_5
|
||||
# 107| valnum = r107_5
|
||||
@@ -782,20 +818,24 @@ test.cpp:
|
||||
# 109| valnum = r107_5
|
||||
# 109| m109_4(int) = Store : &:r109_1, r109_3
|
||||
# 109| valnum = r107_5
|
||||
# 104| v104_8(void) = ReturnIndirection : &:r104_6, m104_7
|
||||
# 104| r104_9(glval<int>) = VariableAddress[#return] :
|
||||
# 104| v104_10(void) = ReturnIndirection : &:r104_8, m104_9
|
||||
# 104| r104_11(glval<int>) = VariableAddress[#return] :
|
||||
# 104| valnum = r109_1
|
||||
# 104| v104_10(void) = ReturnValue : &:r104_9, m109_4
|
||||
# 104| v104_11(void) = UnmodeledUse : mu*
|
||||
# 104| v104_12(void) = AliasedUse : ~m104_2
|
||||
# 104| v104_13(void) = ExitFunction :
|
||||
# 104| v104_12(void) = ReturnValue : &:r104_11, m109_4
|
||||
# 104| v104_13(void) = UnmodeledUse : mu*
|
||||
# 104| v104_14(void) = AliasedUse : m104_3
|
||||
# 104| v104_15(void) = ExitFunction :
|
||||
|
||||
# 112| void test06()
|
||||
# 112| Block 0
|
||||
# 112| v112_1(void) = EnterFunction :
|
||||
# 112| m112_2(unknown) = AliasedDefinition :
|
||||
# 112| valnum = unique
|
||||
# 112| mu112_3(unknown) = UnmodeledDefinition :
|
||||
# 112| m112_3(unknown) = InitializeNonLocal :
|
||||
# 112| valnum = unique
|
||||
# 112| m112_4(unknown) = Chi : total:m112_2, partial:m112_3
|
||||
# 112| valnum = unique
|
||||
# 112| mu112_5(unknown) = UnmodeledDefinition :
|
||||
# 112| valnum = unique
|
||||
# 113| r113_1(glval<char[2]>) = StringConstant["a"] :
|
||||
# 113| valnum = r113_1
|
||||
@@ -806,7 +846,7 @@ test.cpp:
|
||||
# 116| r116_1(glval<char[2]>) = StringConstant["c"] :
|
||||
# 116| valnum = unique
|
||||
# 117| v117_1(void) = NoOp :
|
||||
# 112| v112_4(void) = ReturnVoid :
|
||||
# 112| v112_5(void) = UnmodeledUse : mu*
|
||||
# 112| v112_6(void) = AliasedUse : ~m112_2
|
||||
# 112| v112_7(void) = ExitFunction :
|
||||
# 112| v112_6(void) = ReturnVoid :
|
||||
# 112| v112_7(void) = UnmodeledUse : mu*
|
||||
# 112| v112_8(void) = AliasedUse : m112_3
|
||||
# 112| v112_9(void) = ExitFunction :
|
||||
|
||||
Reference in New Issue
Block a user