mirror of
https://github.com/github/codeql.git
synced 2025-12-16 16:53:25 +01:00
C++: Print target variable name for Load and Store, if known
Now that we've started printing the targets of `Call` instructions in the IR dumps, I figured I might as well print the names of the variable being loaded or stored as well. We could potentially extend this to match fields, array elements, etc., but that's quite a bit more work.
This commit is contained in:
Dave Bartolomeo
@@ -804,12 +804,26 @@ class CopyValueInstruction extends CopyInstruction, UnaryInstruction {
|
||||
final override UnaryOperand getSourceValueOperand() { result = getAnOperand() }
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a string describing the location pointed to by the specified address operand.
|
||||
*/
|
||||
private string getAddressOperandDescription(AddressOperand operand) {
|
||||
result = operand.getDef().(VariableAddressInstruction).getIRVariable().toString()
|
||||
or
|
||||
not operand.getDef() instanceof VariableAddressInstruction and
|
||||
result = "?"
|
||||
}
|
||||
|
||||
/**
|
||||
* An instruction that returns a register result containing a copy of its memory operand.
|
||||
*/
|
||||
class LoadInstruction extends CopyInstruction {
|
||||
LoadInstruction() { getOpcode() instanceof Opcode::Load }
|
||||
|
||||
final override string getImmediateString() {
|
||||
result = getAddressOperandDescription(getSourceAddressOperand())
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the operand that provides the address of the value being loaded.
|
||||
*/
|
||||
@@ -829,6 +843,10 @@ class LoadInstruction extends CopyInstruction {
|
||||
class StoreInstruction extends CopyInstruction {
|
||||
StoreInstruction() { getOpcode() instanceof Opcode::Store }
|
||||
|
||||
final override string getImmediateString() {
|
||||
result = getAddressOperandDescription(getDestinationAddressOperand())
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the operand that provides the address of the location to which the value will be stored.
|
||||
*/
|
||||
|
||||
@@ -804,12 +804,26 @@ class CopyValueInstruction extends CopyInstruction, UnaryInstruction {
|
||||
final override UnaryOperand getSourceValueOperand() { result = getAnOperand() }
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a string describing the location pointed to by the specified address operand.
|
||||
*/
|
||||
private string getAddressOperandDescription(AddressOperand operand) {
|
||||
result = operand.getDef().(VariableAddressInstruction).getIRVariable().toString()
|
||||
or
|
||||
not operand.getDef() instanceof VariableAddressInstruction and
|
||||
result = "?"
|
||||
}
|
||||
|
||||
/**
|
||||
* An instruction that returns a register result containing a copy of its memory operand.
|
||||
*/
|
||||
class LoadInstruction extends CopyInstruction {
|
||||
LoadInstruction() { getOpcode() instanceof Opcode::Load }
|
||||
|
||||
final override string getImmediateString() {
|
||||
result = getAddressOperandDescription(getSourceAddressOperand())
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the operand that provides the address of the value being loaded.
|
||||
*/
|
||||
@@ -829,6 +843,10 @@ class LoadInstruction extends CopyInstruction {
|
||||
class StoreInstruction extends CopyInstruction {
|
||||
StoreInstruction() { getOpcode() instanceof Opcode::Store }
|
||||
|
||||
final override string getImmediateString() {
|
||||
result = getAddressOperandDescription(getDestinationAddressOperand())
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the operand that provides the address of the location to which the value will be stored.
|
||||
*/
|
||||
|
||||
@@ -804,12 +804,26 @@ class CopyValueInstruction extends CopyInstruction, UnaryInstruction {
|
||||
final override UnaryOperand getSourceValueOperand() { result = getAnOperand() }
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a string describing the location pointed to by the specified address operand.
|
||||
*/
|
||||
private string getAddressOperandDescription(AddressOperand operand) {
|
||||
result = operand.getDef().(VariableAddressInstruction).getIRVariable().toString()
|
||||
or
|
||||
not operand.getDef() instanceof VariableAddressInstruction and
|
||||
result = "?"
|
||||
}
|
||||
|
||||
/**
|
||||
* An instruction that returns a register result containing a copy of its memory operand.
|
||||
*/
|
||||
class LoadInstruction extends CopyInstruction {
|
||||
LoadInstruction() { getOpcode() instanceof Opcode::Load }
|
||||
|
||||
final override string getImmediateString() {
|
||||
result = getAddressOperandDescription(getSourceAddressOperand())
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the operand that provides the address of the value being loaded.
|
||||
*/
|
||||
@@ -829,6 +843,10 @@ class LoadInstruction extends CopyInstruction {
|
||||
class StoreInstruction extends CopyInstruction {
|
||||
StoreInstruction() { getOpcode() instanceof Opcode::Store }
|
||||
|
||||
final override string getImmediateString() {
|
||||
result = getAddressOperandDescription(getDestinationAddressOperand())
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the operand that provides the address of the location to which the value will be stored.
|
||||
*/
|
||||
|
||||
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
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -30,39 +30,39 @@ test.cpp:
|
||||
# 3| valnum = unique
|
||||
# 5| r5_1(glval<int>) = VariableAddress[p0] :
|
||||
# 5| valnum = r1_5, r5_1, r6_1
|
||||
# 5| r5_2(int) = Load : &:r5_1, m1_6
|
||||
# 5| r5_2(int) = Load[p0] : &:r5_1, m1_6
|
||||
# 5| valnum = m1_6, r5_2, r6_2
|
||||
# 5| r5_3(glval<int>) = VariableAddress[p1] :
|
||||
# 5| valnum = r1_7, r5_3, r6_3
|
||||
# 5| r5_4(int) = Load : &:r5_3, m1_8
|
||||
# 5| r5_4(int) = Load[p1] : &:r5_3, m1_8
|
||||
# 5| valnum = m1_8, r5_4, r6_4
|
||||
# 5| r5_5(int) = Add : r5_2, r5_4
|
||||
# 5| valnum = m5_7, m6_7, m7_4, r5_5, r6_5, r7_2
|
||||
# 5| r5_6(glval<int>) = VariableAddress[x] :
|
||||
# 5| valnum = r2_1, r5_6, r6_6, r7_1
|
||||
# 5| m5_7(int) = Store : &:r5_6, r5_5
|
||||
# 5| m5_7(int) = Store[x] : &:r5_6, r5_5
|
||||
# 5| valnum = m5_7, m6_7, m7_4, r5_5, r6_5, r7_2
|
||||
# 6| r6_1(glval<int>) = VariableAddress[p0] :
|
||||
# 6| valnum = r1_5, r5_1, r6_1
|
||||
# 6| r6_2(int) = Load : &:r6_1, m1_6
|
||||
# 6| r6_2(int) = Load[p0] : &:r6_1, m1_6
|
||||
# 6| valnum = m1_6, r5_2, r6_2
|
||||
# 6| r6_3(glval<int>) = VariableAddress[p1] :
|
||||
# 6| valnum = r1_7, r5_3, r6_3
|
||||
# 6| r6_4(int) = Load : &:r6_3, m1_8
|
||||
# 6| r6_4(int) = Load[p1] : &:r6_3, m1_8
|
||||
# 6| valnum = m1_8, r5_4, r6_4
|
||||
# 6| r6_5(int) = Add : r6_2, r6_4
|
||||
# 6| valnum = m5_7, m6_7, m7_4, r5_5, r6_5, r7_2
|
||||
# 6| r6_6(glval<int>) = VariableAddress[x] :
|
||||
# 6| valnum = r2_1, r5_6, r6_6, r7_1
|
||||
# 6| m6_7(int) = Store : &:r6_6, r6_5
|
||||
# 6| m6_7(int) = Store[x] : &:r6_6, r6_5
|
||||
# 6| valnum = m5_7, m6_7, m7_4, r5_5, r6_5, r7_2
|
||||
# 7| r7_1(glval<int>) = VariableAddress[x] :
|
||||
# 7| valnum = r2_1, r5_6, r6_6, r7_1
|
||||
# 7| r7_2(int) = Load : &:r7_1, m6_7
|
||||
# 7| r7_2(int) = Load[x] : &:r7_1, m6_7
|
||||
# 7| valnum = m5_7, m6_7, m7_4, r5_5, r6_5, r7_2
|
||||
# 7| r7_3(glval<int>) = VariableAddress[y] :
|
||||
# 7| valnum = r2_3, r7_3
|
||||
# 7| m7_4(int) = Store : &:r7_3, r7_2
|
||||
# 7| m7_4(int) = Store[y] : &:r7_3, r7_2
|
||||
# 7| valnum = m5_7, m6_7, m7_4, r5_5, r6_5, r7_2
|
||||
# 8| v8_1(void) = NoOp :
|
||||
# 1| v1_9(void) = ReturnVoid :
|
||||
@@ -100,51 +100,51 @@ test.cpp:
|
||||
# 14| valnum = unique
|
||||
# 16| r16_1(glval<int>) = VariableAddress[p0] :
|
||||
# 16| valnum = r12_5, r16_1, r17_1
|
||||
# 16| r16_2(int) = Load : &:r16_1, m12_6
|
||||
# 16| r16_2(int) = Load[p0] : &:r16_1, m12_6
|
||||
# 16| valnum = m12_6, r16_2, r17_2
|
||||
# 16| r16_3(glval<int>) = VariableAddress[p1] :
|
||||
# 16| valnum = r12_7, r16_3, r17_3
|
||||
# 16| r16_4(int) = Load : &:r16_3, m12_8
|
||||
# 16| r16_4(int) = Load[p1] : &:r16_3, m12_8
|
||||
# 16| valnum = m12_8, r16_4, r17_4
|
||||
# 16| r16_5(int) = Add : r16_2, r16_4
|
||||
# 16| valnum = r16_5, r17_5
|
||||
# 16| r16_6(glval<int>) = VariableAddress[global01] :
|
||||
# 16| valnum = r16_6, r17_6
|
||||
# 16| r16_7(int) = Load : &:r16_6, ~m12_3
|
||||
# 16| r16_7(int) = Load[global01] : &:r16_6, ~m12_3
|
||||
# 16| valnum = r16_7, r17_7
|
||||
# 16| r16_8(int) = Add : r16_5, r16_7
|
||||
# 16| valnum = m16_10, m17_10, m18_4, r16_8, r17_8, r18_2
|
||||
# 16| r16_9(glval<int>) = VariableAddress[x] :
|
||||
# 16| valnum = r13_1, r16_9, r17_9, r18_1
|
||||
# 16| m16_10(int) = Store : &:r16_9, r16_8
|
||||
# 16| m16_10(int) = Store[x] : &:r16_9, r16_8
|
||||
# 16| valnum = m16_10, m17_10, m18_4, r16_8, r17_8, r18_2
|
||||
# 17| r17_1(glval<int>) = VariableAddress[p0] :
|
||||
# 17| valnum = r12_5, r16_1, r17_1
|
||||
# 17| r17_2(int) = Load : &:r17_1, m12_6
|
||||
# 17| r17_2(int) = Load[p0] : &:r17_1, m12_6
|
||||
# 17| valnum = m12_6, r16_2, r17_2
|
||||
# 17| r17_3(glval<int>) = VariableAddress[p1] :
|
||||
# 17| valnum = r12_7, r16_3, r17_3
|
||||
# 17| r17_4(int) = Load : &:r17_3, m12_8
|
||||
# 17| r17_4(int) = Load[p1] : &:r17_3, m12_8
|
||||
# 17| valnum = m12_8, r16_4, r17_4
|
||||
# 17| r17_5(int) = Add : r17_2, r17_4
|
||||
# 17| valnum = r16_5, r17_5
|
||||
# 17| r17_6(glval<int>) = VariableAddress[global01] :
|
||||
# 17| valnum = r16_6, r17_6
|
||||
# 17| r17_7(int) = Load : &:r17_6, ~m12_3
|
||||
# 17| r17_7(int) = Load[global01] : &:r17_6, ~m12_3
|
||||
# 17| valnum = r16_7, r17_7
|
||||
# 17| r17_8(int) = Add : r17_5, r17_7
|
||||
# 17| valnum = m16_10, m17_10, m18_4, r16_8, r17_8, r18_2
|
||||
# 17| r17_9(glval<int>) = VariableAddress[x] :
|
||||
# 17| valnum = r13_1, r16_9, r17_9, r18_1
|
||||
# 17| m17_10(int) = Store : &:r17_9, r17_8
|
||||
# 17| m17_10(int) = Store[x] : &:r17_9, r17_8
|
||||
# 17| valnum = m16_10, m17_10, m18_4, r16_8, r17_8, r18_2
|
||||
# 18| r18_1(glval<int>) = VariableAddress[x] :
|
||||
# 18| valnum = r13_1, r16_9, r17_9, r18_1
|
||||
# 18| r18_2(int) = Load : &:r18_1, m17_10
|
||||
# 18| r18_2(int) = Load[x] : &:r18_1, m17_10
|
||||
# 18| valnum = m16_10, m17_10, m18_4, r16_8, r17_8, r18_2
|
||||
# 18| r18_3(glval<int>) = VariableAddress[y] :
|
||||
# 18| valnum = r13_3, r18_3
|
||||
# 18| m18_4(int) = Store : &:r18_3, r18_2
|
||||
# 18| m18_4(int) = Store[y] : &:r18_3, r18_2
|
||||
# 18| valnum = m16_10, m17_10, m18_4, r16_8, r17_8, r18_2
|
||||
# 19| v19_1(void) = NoOp :
|
||||
# 12| v12_9(void) = ReturnVoid :
|
||||
@@ -182,23 +182,23 @@ test.cpp:
|
||||
# 27| valnum = unique
|
||||
# 29| r29_1(glval<int>) = VariableAddress[p0] :
|
||||
# 29| valnum = r25_5, r29_1, r31_1
|
||||
# 29| r29_2(int) = Load : &:r29_1, m25_6
|
||||
# 29| r29_2(int) = Load[p0] : &:r29_1, m25_6
|
||||
# 29| valnum = m25_6, r29_2, r31_2
|
||||
# 29| r29_3(glval<int>) = VariableAddress[p1] :
|
||||
# 29| valnum = r25_7, r29_3, r31_3
|
||||
# 29| r29_4(int) = Load : &:r29_3, m25_8
|
||||
# 29| r29_4(int) = Load[p1] : &:r29_3, m25_8
|
||||
# 29| valnum = m25_8, r29_4, r31_4
|
||||
# 29| r29_5(int) = Add : r29_2, r29_4
|
||||
# 29| valnum = r29_5, r31_5
|
||||
# 29| r29_6(glval<int>) = VariableAddress[global02] :
|
||||
# 29| valnum = r29_6, r31_6
|
||||
# 29| r29_7(int) = Load : &:r29_6, ~m25_3
|
||||
# 29| r29_7(int) = Load[global02] : &:r29_6, ~m25_3
|
||||
# 29| valnum = unique
|
||||
# 29| r29_8(int) = Add : r29_5, r29_7
|
||||
# 29| valnum = m29_10, r29_8
|
||||
# 29| r29_9(glval<int>) = VariableAddress[x] :
|
||||
# 29| valnum = r26_1, r29_9, r31_9, r32_1
|
||||
# 29| m29_10(int) = Store : &:r29_9, r29_8
|
||||
# 29| m29_10(int) = Store[x] : &:r29_9, r29_8
|
||||
# 29| valnum = m29_10, r29_8
|
||||
# 30| r30_1(glval<unknown>) = FunctionAddress[change_global02] :
|
||||
# 30| valnum = unique
|
||||
@@ -209,31 +209,31 @@ test.cpp:
|
||||
# 30| valnum = unique
|
||||
# 31| r31_1(glval<int>) = VariableAddress[p0] :
|
||||
# 31| valnum = r25_5, r29_1, r31_1
|
||||
# 31| r31_2(int) = Load : &:r31_1, m25_6
|
||||
# 31| r31_2(int) = Load[p0] : &:r31_1, m25_6
|
||||
# 31| valnum = m25_6, r29_2, r31_2
|
||||
# 31| r31_3(glval<int>) = VariableAddress[p1] :
|
||||
# 31| valnum = r25_7, r29_3, r31_3
|
||||
# 31| r31_4(int) = Load : &:r31_3, m25_8
|
||||
# 31| r31_4(int) = Load[p1] : &:r31_3, m25_8
|
||||
# 31| valnum = m25_8, r29_4, r31_4
|
||||
# 31| r31_5(int) = Add : r31_2, r31_4
|
||||
# 31| valnum = r29_5, r31_5
|
||||
# 31| r31_6(glval<int>) = VariableAddress[global02] :
|
||||
# 31| valnum = r29_6, r31_6
|
||||
# 31| r31_7(int) = Load : &:r31_6, ~m30_4
|
||||
# 31| r31_7(int) = Load[global02] : &:r31_6, ~m30_4
|
||||
# 31| valnum = unique
|
||||
# 31| r31_8(int) = Add : r31_5, r31_7
|
||||
# 31| valnum = m31_10, m32_4, r31_8, r32_2
|
||||
# 31| r31_9(glval<int>) = VariableAddress[x] :
|
||||
# 31| valnum = r26_1, r29_9, r31_9, r32_1
|
||||
# 31| m31_10(int) = Store : &:r31_9, r31_8
|
||||
# 31| m31_10(int) = Store[x] : &:r31_9, r31_8
|
||||
# 31| valnum = m31_10, m32_4, r31_8, r32_2
|
||||
# 32| r32_1(glval<int>) = VariableAddress[x] :
|
||||
# 32| valnum = r26_1, r29_9, r31_9, r32_1
|
||||
# 32| r32_2(int) = Load : &:r32_1, m31_10
|
||||
# 32| r32_2(int) = Load[x] : &:r32_1, m31_10
|
||||
# 32| valnum = m31_10, m32_4, r31_8, r32_2
|
||||
# 32| r32_3(glval<int>) = VariableAddress[y] :
|
||||
# 32| valnum = r26_3, r32_3
|
||||
# 32| m32_4(int) = Store : &:r32_3, r32_2
|
||||
# 32| m32_4(int) = Store[y] : &:r32_3, r32_2
|
||||
# 32| valnum = m31_10, m32_4, r31_8, r32_2
|
||||
# 33| v33_1(void) = NoOp :
|
||||
# 25| v25_9(void) = ReturnVoid :
|
||||
@@ -261,7 +261,7 @@ test.cpp:
|
||||
# 39| valnum = r39_9, r44_2
|
||||
# 39| m39_10(int *) = InitializeParameter[p2] : &:r39_9
|
||||
# 39| valnum = m39_10, r39_11, r44_3, r44_4
|
||||
# 39| r39_11(int *) = Load : &:r39_9, m39_10
|
||||
# 39| r39_11(int *) = Load[p2] : &:r39_9, m39_10
|
||||
# 39| valnum = m39_10, r39_11, r44_3, r44_4
|
||||
# 39| m39_12(unknown) = InitializeIndirection[p2] : &:r39_11
|
||||
# 39| valnum = unique
|
||||
@@ -279,63 +279,63 @@ test.cpp:
|
||||
# 41| valnum = unique
|
||||
# 43| r43_1(glval<int>) = VariableAddress[p0] :
|
||||
# 43| valnum = r39_5, r43_1, r45_1
|
||||
# 43| r43_2(int) = Load : &:r43_1, m39_6
|
||||
# 43| r43_2(int) = Load[p0] : &:r43_1, m39_6
|
||||
# 43| valnum = m39_6, r43_2, r45_2
|
||||
# 43| r43_3(glval<int>) = VariableAddress[p1] :
|
||||
# 43| valnum = r39_7, r43_3, r45_3
|
||||
# 43| r43_4(int) = Load : &:r43_3, m39_8
|
||||
# 43| r43_4(int) = Load[p1] : &:r43_3, m39_8
|
||||
# 43| valnum = m39_8, r43_4, r45_4
|
||||
# 43| r43_5(int) = Add : r43_2, r43_4
|
||||
# 43| valnum = r43_5, r45_5
|
||||
# 43| r43_6(glval<int>) = VariableAddress[global03] :
|
||||
# 43| valnum = r43_6, r45_6
|
||||
# 43| r43_7(int) = Load : &:r43_6, ~m39_3
|
||||
# 43| r43_7(int) = Load[global03] : &:r43_6, ~m39_3
|
||||
# 43| valnum = r43_7, r45_7
|
||||
# 43| r43_8(int) = Add : r43_5, r43_7
|
||||
# 43| valnum = m43_10, m45_10, m46_4, r43_8, r45_8, r46_2
|
||||
# 43| r43_9(glval<int>) = VariableAddress[x] :
|
||||
# 43| valnum = r40_1, r43_9, r45_9, r46_1
|
||||
# 43| m43_10(int) = Store : &:r43_9, r43_8
|
||||
# 43| m43_10(int) = Store[x] : &:r43_9, r43_8
|
||||
# 43| valnum = m43_10, m45_10, m46_4, r43_8, r45_8, r46_2
|
||||
# 44| r44_1(int) = Constant[0] :
|
||||
# 44| valnum = m44_5, r44_1
|
||||
# 44| r44_2(glval<int *>) = VariableAddress[p2] :
|
||||
# 44| valnum = r39_9, r44_2
|
||||
# 44| r44_3(int *) = Load : &:r44_2, m39_10
|
||||
# 44| r44_3(int *) = Load[p2] : &:r44_2, m39_10
|
||||
# 44| valnum = m39_10, r39_11, r44_3, r44_4
|
||||
# 44| r44_4(glval<int>) = CopyValue : r44_3
|
||||
# 44| valnum = m39_10, r39_11, r44_3, r44_4
|
||||
# 44| m44_5(int) = Store : &:r44_4, r44_1
|
||||
# 44| m44_5(int) = Store[?] : &:r44_4, r44_1
|
||||
# 44| valnum = m44_5, r44_1
|
||||
# 44| m44_6(unknown) = Chi : total:m39_12, partial:m44_5
|
||||
# 44| valnum = unique
|
||||
# 45| r45_1(glval<int>) = VariableAddress[p0] :
|
||||
# 45| valnum = r39_5, r43_1, r45_1
|
||||
# 45| r45_2(int) = Load : &:r45_1, m39_6
|
||||
# 45| r45_2(int) = Load[p0] : &:r45_1, m39_6
|
||||
# 45| valnum = m39_6, r43_2, r45_2
|
||||
# 45| r45_3(glval<int>) = VariableAddress[p1] :
|
||||
# 45| valnum = r39_7, r43_3, r45_3
|
||||
# 45| r45_4(int) = Load : &:r45_3, m39_8
|
||||
# 45| r45_4(int) = Load[p1] : &:r45_3, m39_8
|
||||
# 45| valnum = m39_8, r43_4, r45_4
|
||||
# 45| r45_5(int) = Add : r45_2, r45_4
|
||||
# 45| valnum = r43_5, r45_5
|
||||
# 45| r45_6(glval<int>) = VariableAddress[global03] :
|
||||
# 45| valnum = r43_6, r45_6
|
||||
# 45| r45_7(int) = Load : &:r45_6, ~m39_3
|
||||
# 45| r45_7(int) = Load[global03] : &:r45_6, ~m39_3
|
||||
# 45| valnum = r43_7, r45_7
|
||||
# 45| r45_8(int) = Add : r45_5, r45_7
|
||||
# 45| valnum = m43_10, m45_10, m46_4, r43_8, r45_8, r46_2
|
||||
# 45| r45_9(glval<int>) = VariableAddress[x] :
|
||||
# 45| valnum = r40_1, r43_9, r45_9, r46_1
|
||||
# 45| m45_10(int) = Store : &:r45_9, r45_8
|
||||
# 45| m45_10(int) = Store[x] : &:r45_9, r45_8
|
||||
# 45| valnum = m43_10, m45_10, m46_4, r43_8, r45_8, r46_2
|
||||
# 46| r46_1(glval<int>) = VariableAddress[x] :
|
||||
# 46| valnum = r40_1, r43_9, r45_9, r46_1
|
||||
# 46| r46_2(int) = Load : &:r46_1, m45_10
|
||||
# 46| r46_2(int) = Load[x] : &:r46_1, m45_10
|
||||
# 46| valnum = m43_10, m45_10, m46_4, r43_8, r45_8, r46_2
|
||||
# 46| r46_3(glval<int>) = VariableAddress[y] :
|
||||
# 46| valnum = r40_3, r46_3
|
||||
# 46| m46_4(int) = Store : &:r46_3, r46_2
|
||||
# 46| m46_4(int) = Store[y] : &:r46_3, r46_2
|
||||
# 46| valnum = m43_10, m45_10, m46_4, r43_8, r45_8, r46_2
|
||||
# 47| v47_1(void) = NoOp :
|
||||
# 39| v39_13(void) = ReturnIndirection[p2] : &:r39_11, m44_6
|
||||
@@ -356,7 +356,7 @@ test.cpp:
|
||||
# 49| valnum = r49_5, r53_2, r56_6
|
||||
# 49| m49_6(char *) = InitializeParameter[str] : &:r49_5
|
||||
# 49| valnum = m49_6, r49_7, r53_3, r56_7
|
||||
# 49| r49_7(char *) = Load : &:r49_5, m49_6
|
||||
# 49| r49_7(char *) = Load[str] : &:r49_5, m49_6
|
||||
# 49| valnum = m49_6, r49_7, r53_3, r56_7
|
||||
# 49| m49_8(unknown) = InitializeIndirection[str] : &:r49_7
|
||||
# 49| valnum = unique
|
||||
@@ -364,7 +364,7 @@ test.cpp:
|
||||
# 49| valnum = r49_9, r55_1
|
||||
# 49| m49_10(char *) = InitializeParameter[chars] : &:r49_9
|
||||
# 49| valnum = m49_10, m55_4, r49_11, r55_2
|
||||
# 49| r49_11(char *) = Load : &:r49_9, m49_10
|
||||
# 49| r49_11(char *) = Load[chars] : &:r49_9, m49_10
|
||||
# 49| valnum = m49_10, m55_4, r49_11, r55_2
|
||||
# 49| m49_12(unknown) = InitializeIndirection[chars] : &:r49_11
|
||||
# 49| valnum = unique
|
||||
@@ -376,7 +376,7 @@ test.cpp:
|
||||
# 51| valnum = r51_1, r62_1, r65_2
|
||||
# 51| r51_2(unsigned int) = Constant[0] :
|
||||
# 51| valnum = m51_3, r51_2
|
||||
# 51| m51_3(unsigned int) = Store : &:r51_1, r51_2
|
||||
# 51| m51_3(unsigned int) = Store[result] : &:r51_1, r51_2
|
||||
# 51| valnum = m51_3, r51_2
|
||||
#-----| Goto -> Block 1
|
||||
|
||||
@@ -385,9 +385,9 @@ test.cpp:
|
||||
# 53| valnum = m53_1, m65_4, r62_2, r65_3
|
||||
# 53| r53_2(glval<char *>) = VariableAddress[str] :
|
||||
# 53| valnum = r49_5, r53_2, r56_6
|
||||
# 53| r53_3(char *) = Load : &:r53_2, m49_6
|
||||
# 53| r53_3(char *) = Load[str] : &:r53_2, m49_6
|
||||
# 53| valnum = m49_6, r49_7, r53_3, r56_7
|
||||
# 53| r53_4(char) = Load : &:r53_3, ~m49_8
|
||||
# 53| r53_4(char) = Load[?] : &:r53_3, ~m49_8
|
||||
# 53| valnum = r53_4, r56_8
|
||||
# 53| r53_5(int) = Convert : r53_4
|
||||
# 53| valnum = r53_5, r56_9
|
||||
@@ -402,11 +402,11 @@ test.cpp:
|
||||
# 55| Block 2
|
||||
# 55| r55_1(glval<char *>) = VariableAddress[chars] :
|
||||
# 55| valnum = r49_9, r55_1
|
||||
# 55| r55_2(char *) = Load : &:r55_1, m49_10
|
||||
# 55| r55_2(char *) = Load[chars] : &:r55_1, m49_10
|
||||
# 55| valnum = m49_10, m55_4, r49_11, r55_2
|
||||
# 55| r55_3(glval<char *>) = VariableAddress[ptr] :
|
||||
# 55| valnum = r50_1, r55_3, r56_12, r56_19, r56_2, r59_1
|
||||
# 55| m55_4(char *) = Store : &:r55_3, r55_2
|
||||
# 55| m55_4(char *) = Store[ptr] : &:r55_3, r55_2
|
||||
# 55| valnum = m49_10, m55_4, r49_11, r55_2
|
||||
#-----| Goto -> Block 3
|
||||
|
||||
@@ -415,17 +415,17 @@ test.cpp:
|
||||
# 56| valnum = m56_1, r56_13, r56_20, r56_3, r59_2
|
||||
# 56| r56_2(glval<char *>) = VariableAddress[ptr] :
|
||||
# 56| valnum = r50_1, r55_3, r56_12, r56_19, r56_2, r59_1
|
||||
# 56| r56_3(char *) = Load : &:r56_2, m56_1
|
||||
# 56| r56_3(char *) = Load[ptr] : &:r56_2, m56_1
|
||||
# 56| valnum = m56_1, r56_13, r56_20, r56_3, r59_2
|
||||
# 56| r56_4(char) = Load : &:r56_3, ~m49_4
|
||||
# 56| r56_4(char) = Load[?] : &:r56_3, ~m49_4
|
||||
# 56| valnum = r56_14, r56_4, r59_3
|
||||
# 56| r56_5(int) = Convert : r56_4
|
||||
# 56| valnum = r56_15, r56_5, r59_4
|
||||
# 56| r56_6(glval<char *>) = VariableAddress[str] :
|
||||
# 56| valnum = r49_5, r53_2, r56_6
|
||||
# 56| r56_7(char *) = Load : &:r56_6, m49_6
|
||||
# 56| r56_7(char *) = Load[str] : &:r56_6, m49_6
|
||||
# 56| valnum = m49_6, r49_7, r53_3, r56_7
|
||||
# 56| r56_8(char) = Load : &:r56_7, ~m49_8
|
||||
# 56| r56_8(char) = Load[?] : &:r56_7, ~m49_8
|
||||
# 56| valnum = r53_4, r56_8
|
||||
# 56| r56_9(int) = Convert : r56_8
|
||||
# 56| valnum = r53_5, r56_9
|
||||
@@ -438,9 +438,9 @@ test.cpp:
|
||||
# 56| Block 4
|
||||
# 56| r56_12(glval<char *>) = VariableAddress[ptr] :
|
||||
# 56| valnum = r50_1, r55_3, r56_12, r56_19, r56_2, r59_1
|
||||
# 56| r56_13(char *) = Load : &:r56_12, m56_1
|
||||
# 56| r56_13(char *) = Load[ptr] : &:r56_12, m56_1
|
||||
# 56| valnum = m56_1, r56_13, r56_20, r56_3, r59_2
|
||||
# 56| r56_14(char) = Load : &:r56_13, ~m49_4
|
||||
# 56| r56_14(char) = Load[?] : &:r56_13, ~m49_4
|
||||
# 56| valnum = r56_14, r56_4, r59_3
|
||||
# 56| r56_15(int) = Convert : r56_14
|
||||
# 56| valnum = r56_15, r56_5, r59_4
|
||||
@@ -455,22 +455,22 @@ test.cpp:
|
||||
# 56| Block 5
|
||||
# 56| r56_19(glval<char *>) = VariableAddress[ptr] :
|
||||
# 56| valnum = r50_1, r55_3, r56_12, r56_19, r56_2, r59_1
|
||||
# 56| r56_20(char *) = Load : &:r56_19, m56_1
|
||||
# 56| r56_20(char *) = Load[ptr] : &:r56_19, m56_1
|
||||
# 56| valnum = m56_1, r56_13, r56_20, r56_3, r59_2
|
||||
# 56| r56_21(int) = Constant[1] :
|
||||
# 56| valnum = unique
|
||||
# 56| r56_22(char *) = PointerAdd[1] : r56_20, r56_21
|
||||
# 56| valnum = m56_23, r56_22
|
||||
# 56| m56_23(char *) = Store : &:r56_19, r56_22
|
||||
# 56| m56_23(char *) = Store[ptr] : &:r56_19, r56_22
|
||||
# 56| valnum = m56_23, r56_22
|
||||
#-----| Goto (back edge) -> Block 3
|
||||
|
||||
# 59| Block 6
|
||||
# 59| r59_1(glval<char *>) = VariableAddress[ptr] :
|
||||
# 59| valnum = r50_1, r55_3, r56_12, r56_19, r56_2, r59_1
|
||||
# 59| r59_2(char *) = Load : &:r59_1, m56_1
|
||||
# 59| r59_2(char *) = Load[ptr] : &:r59_1, m56_1
|
||||
# 59| valnum = m56_1, r56_13, r56_20, r56_3, r59_2
|
||||
# 59| r59_3(char) = Load : &:r59_2, ~m49_4
|
||||
# 59| r59_3(char) = Load[?] : &:r59_2, ~m49_4
|
||||
# 59| valnum = r56_14, r56_4, r59_3
|
||||
# 59| r59_4(int) = Convert : r59_3
|
||||
# 59| valnum = r56_15, r56_5, r59_4
|
||||
@@ -489,13 +489,13 @@ test.cpp:
|
||||
# 62| Block 8
|
||||
# 62| r62_1(glval<unsigned int>) = VariableAddress[result] :
|
||||
# 62| valnum = r51_1, r62_1, r65_2
|
||||
# 62| r62_2(unsigned int) = Load : &:r62_1, m53_1
|
||||
# 62| r62_2(unsigned int) = Load[result] : &:r62_1, m53_1
|
||||
# 62| valnum = m53_1, m65_4, r62_2, r65_3
|
||||
# 62| r62_3(unsigned int) = Constant[1] :
|
||||
# 62| valnum = unique
|
||||
# 62| r62_4(unsigned int) = Add : r62_2, r62_3
|
||||
# 62| valnum = m62_5, r62_4
|
||||
# 62| m62_5(unsigned int) = Store : &:r62_1, r62_4
|
||||
# 62| m62_5(unsigned int) = Store[result] : &:r62_1, r62_4
|
||||
# 62| valnum = m62_5, r62_4
|
||||
#-----| Goto (back edge) -> Block 1
|
||||
|
||||
@@ -505,9 +505,9 @@ test.cpp:
|
||||
# 65| valnum = r49_15, r65_1
|
||||
# 65| r65_2(glval<unsigned int>) = VariableAddress[result] :
|
||||
# 65| valnum = r51_1, r62_1, r65_2
|
||||
# 65| r65_3(unsigned int) = Load : &:r65_2, m53_1
|
||||
# 65| r65_3(unsigned int) = Load[result] : &:r65_2, m53_1
|
||||
# 65| valnum = m53_1, m65_4, r62_2, r65_3
|
||||
# 65| m65_4(unsigned int) = Store : &:r65_1, r65_3
|
||||
# 65| m65_4(unsigned int) = Store[#return] : &:r65_1, r65_3
|
||||
# 65| valnum = m53_1, m65_4, r62_2, r65_3
|
||||
# 49| v49_13(void) = ReturnIndirection[str] : &:r49_7, m49_8
|
||||
# 49| v49_14(void) = ReturnIndirection[chars] : &:r49_11, m49_12
|
||||
@@ -530,7 +530,7 @@ test.cpp:
|
||||
# 75| valnum = r75_5, r79_4, r79_9
|
||||
# 75| m75_6(two_values *) = InitializeParameter[vals] : &:r75_5
|
||||
# 75| valnum = m75_6, r75_7, r79_10, r79_5
|
||||
# 75| r75_7(two_values *) = Load : &:r75_5, m75_6
|
||||
# 75| r75_7(two_values *) = Load[vals] : &:r75_5, m75_6
|
||||
# 75| valnum = m75_6, r75_7, r79_10, r79_5
|
||||
# 75| m75_8(unknown) = InitializeIndirection[vals] : &:r75_7
|
||||
# 75| valnum = unique
|
||||
@@ -546,31 +546,31 @@ test.cpp:
|
||||
# 77| valnum = unique
|
||||
# 77| r77_6(signed short) = Convert : r77_3
|
||||
# 77| valnum = m77_7, r77_6, r79_2
|
||||
# 77| m77_7(signed short) = Store : &:r77_1, r77_6
|
||||
# 77| m77_7(signed short) = Store[v] : &:r77_1, r77_6
|
||||
# 77| valnum = m77_7, r77_6, r79_2
|
||||
# 79| r79_1(glval<signed short>) = VariableAddress[v] :
|
||||
# 79| valnum = r77_1, r79_1, r80_6
|
||||
# 79| r79_2(signed short) = Load : &:r79_1, m77_7
|
||||
# 79| r79_2(signed short) = Load[v] : &:r79_1, m77_7
|
||||
# 79| valnum = m77_7, r77_6, r79_2
|
||||
# 79| r79_3(int) = Convert : r79_2
|
||||
# 79| valnum = unique
|
||||
# 79| r79_4(glval<two_values *>) = VariableAddress[vals] :
|
||||
# 79| valnum = r75_5, r79_4, r79_9
|
||||
# 79| r79_5(two_values *) = Load : &:r79_4, m75_6
|
||||
# 79| r79_5(two_values *) = Load[vals] : &:r79_4, m75_6
|
||||
# 79| valnum = m75_6, r75_7, r79_10, r79_5
|
||||
# 79| r79_6(glval<signed short>) = FieldAddress[val1] : r79_5
|
||||
# 79| valnum = unique
|
||||
# 79| r79_7(signed short) = Load : &:r79_6, ~m75_8
|
||||
# 79| r79_7(signed short) = Load[?] : &:r79_6, ~m75_8
|
||||
# 79| valnum = unique
|
||||
# 79| r79_8(int) = Convert : r79_7
|
||||
# 79| valnum = unique
|
||||
# 79| r79_9(glval<two_values *>) = VariableAddress[vals] :
|
||||
# 79| valnum = r75_5, r79_4, r79_9
|
||||
# 79| r79_10(two_values *) = Load : &:r79_9, m75_6
|
||||
# 79| r79_10(two_values *) = Load[vals] : &:r79_9, m75_6
|
||||
# 79| valnum = m75_6, r75_7, r79_10, r79_5
|
||||
# 79| r79_11(glval<signed short>) = FieldAddress[val2] : r79_10
|
||||
# 79| valnum = unique
|
||||
# 79| r79_12(signed short) = Load : &:r79_11, ~m75_8
|
||||
# 79| r79_12(signed short) = Load[?] : &:r79_11, ~m75_8
|
||||
# 79| valnum = unique
|
||||
# 79| r79_13(int) = Convert : r79_12
|
||||
# 79| valnum = unique
|
||||
@@ -595,7 +595,7 @@ test.cpp:
|
||||
# 80| valnum = m80_7, r80_5
|
||||
# 80| r80_6(glval<signed short>) = VariableAddress[v] :
|
||||
# 80| valnum = r77_1, r79_1, r80_6
|
||||
# 80| m80_7(signed short) = Store : &:r80_6, r80_5
|
||||
# 80| m80_7(signed short) = Store[v] : &:r80_6, r80_5
|
||||
# 80| valnum = m80_7, r80_5
|
||||
#-----| Goto -> Block 2
|
||||
|
||||
@@ -629,7 +629,7 @@ test.cpp:
|
||||
# 84| valnum = r84_9, r88_1
|
||||
# 84| m84_10(void *) = InitializeParameter[p] : &:r84_9
|
||||
# 84| valnum = m84_10, r84_11, r88_2
|
||||
# 84| r84_11(void *) = Load : &:r84_9, m84_10
|
||||
# 84| r84_11(void *) = Load[p] : &:r84_9, m84_10
|
||||
# 84| valnum = m84_10, r84_11, r88_2
|
||||
# 84| m84_12(unknown) = InitializeIndirection[p] : &:r84_11
|
||||
# 84| valnum = unique
|
||||
@@ -639,7 +639,7 @@ test.cpp:
|
||||
# 86| valnum = unique
|
||||
# 88| r88_1(glval<void *>) = VariableAddress[p] :
|
||||
# 88| valnum = r84_9, r88_1
|
||||
# 88| r88_2(void *) = Load : &:r88_1, m84_10
|
||||
# 88| r88_2(void *) = Load[p] : &:r88_1, m84_10
|
||||
# 88| valnum = m84_10, r84_11, r88_2
|
||||
# 88| r88_3(void *) = Constant[0] :
|
||||
# 88| valnum = unique
|
||||
@@ -654,11 +654,11 @@ test.cpp:
|
||||
# 88| valnum = m88_10, m88_6, r88_8
|
||||
# 88| r88_7(glval<int>) = VariableAddress[#temp88:7] :
|
||||
# 88| valnum = r88_13, r88_17, r88_7
|
||||
# 88| r88_8(int) = Load : &:r88_7, m88_6
|
||||
# 88| r88_8(int) = Load[#temp88:7] : &:r88_7, m88_6
|
||||
# 88| valnum = m88_10, m88_6, r88_8
|
||||
# 88| r88_9(glval<int>) = VariableAddress[v] :
|
||||
# 88| valnum = r86_1, r88_9
|
||||
# 88| m88_10(int) = Store : &:r88_9, r88_8
|
||||
# 88| m88_10(int) = Store[v] : &:r88_9, r88_8
|
||||
# 88| valnum = m88_10, m88_6, r88_8
|
||||
# 89| v89_1(void) = NoOp :
|
||||
# 84| v84_13(void) = ReturnIndirection[p] : &:r84_11, m84_12
|
||||
@@ -669,22 +669,22 @@ test.cpp:
|
||||
# 88| Block 2
|
||||
# 88| r88_11(glval<int>) = VariableAddress[x] :
|
||||
# 88| valnum = r84_5, r88_11
|
||||
# 88| r88_12(int) = Load : &:r88_11, m84_6
|
||||
# 88| r88_12(int) = Load[x] : &:r88_11, m84_6
|
||||
# 88| valnum = m84_6, m88_14, r88_12
|
||||
# 88| r88_13(glval<int>) = VariableAddress[#temp88:7] :
|
||||
# 88| valnum = r88_13, r88_17, r88_7
|
||||
# 88| m88_14(int) = Store : &:r88_13, r88_12
|
||||
# 88| m88_14(int) = Store[#temp88:7] : &:r88_13, r88_12
|
||||
# 88| valnum = m84_6, m88_14, r88_12
|
||||
#-----| Goto -> Block 1
|
||||
|
||||
# 88| Block 3
|
||||
# 88| r88_15(glval<int>) = VariableAddress[y] :
|
||||
# 88| valnum = r84_7, r88_15
|
||||
# 88| r88_16(int) = Load : &:r88_15, m84_8
|
||||
# 88| r88_16(int) = Load[y] : &:r88_15, m84_8
|
||||
# 88| valnum = m84_8, m88_18, r88_16
|
||||
# 88| r88_17(glval<int>) = VariableAddress[#temp88:7] :
|
||||
# 88| valnum = r88_13, r88_17, r88_7
|
||||
# 88| m88_18(int) = Store : &:r88_17, r88_16
|
||||
# 88| m88_18(int) = Store[#temp88:7] : &:r88_17, r88_16
|
||||
# 88| valnum = m84_8, m88_18, r88_16
|
||||
#-----| Goto -> Block 1
|
||||
|
||||
@@ -703,19 +703,19 @@ test.cpp:
|
||||
# 92| valnum = m92_4, m92_6, m93_4, r92_2, r92_5, r93_3
|
||||
# 92| r92_3(glval<int>) = VariableAddress[x] :
|
||||
# 92| valnum = r92_1, r92_3, r93_2
|
||||
# 92| m92_4(int) = Store : &:r92_3, r92_2
|
||||
# 92| m92_4(int) = Store[x] : &:r92_3, r92_2
|
||||
# 92| valnum = m92_4, m92_6, m93_4, r92_2, r92_5, r93_3
|
||||
# 92| r92_5(int) = CopyValue : r92_2
|
||||
# 92| valnum = m92_4, m92_6, m93_4, r92_2, r92_5, r93_3
|
||||
# 92| m92_6(int) = Store : &:r92_1, r92_5
|
||||
# 92| m92_6(int) = Store[x] : &:r92_1, r92_5
|
||||
# 92| valnum = m92_4, m92_6, m93_4, r92_2, r92_5, r93_3
|
||||
# 93| r93_1(glval<int>) = VariableAddress[#return] :
|
||||
# 93| valnum = r91_5, r93_1
|
||||
# 93| r93_2(glval<int>) = VariableAddress[x] :
|
||||
# 93| valnum = r92_1, r92_3, r93_2
|
||||
# 93| r93_3(int) = Load : &:r93_2, m92_6
|
||||
# 93| r93_3(int) = Load[x] : &:r93_2, m92_6
|
||||
# 93| valnum = m92_4, m92_6, m93_4, r92_2, r92_5, r93_3
|
||||
# 93| m93_4(int) = Store : &:r93_1, r93_3
|
||||
# 93| m93_4(int) = Store[#return] : &:r93_1, r93_3
|
||||
# 93| valnum = m92_4, m92_6, m93_4, r92_2, r92_5, r93_3
|
||||
# 91| r91_5(glval<int>) = VariableAddress[#return] :
|
||||
# 91| valnum = r91_5, r93_1
|
||||
@@ -736,7 +736,7 @@ test.cpp:
|
||||
# 104| valnum = r104_5, r105_2, r106_2
|
||||
# 104| m104_6(Derived *) = InitializeParameter[pd] : &:r104_5
|
||||
# 104| valnum = m104_6, r104_7, r105_3, r106_3
|
||||
# 104| r104_7(Derived *) = Load : &:r104_5, m104_6
|
||||
# 104| r104_7(Derived *) = Load[pd] : &:r104_5, m104_6
|
||||
# 104| valnum = m104_6, r104_7, r105_3, r106_3
|
||||
# 104| m104_8(unknown) = InitializeIndirection[pd] : &:r104_7
|
||||
# 104| valnum = unique
|
||||
@@ -744,45 +744,45 @@ test.cpp:
|
||||
# 105| valnum = unique
|
||||
# 105| r105_2(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 105| valnum = r104_5, r105_2, r106_2
|
||||
# 105| r105_3(Derived *) = Load : &:r105_2, m104_6
|
||||
# 105| r105_3(Derived *) = Load[pd] : &:r105_2, m104_6
|
||||
# 105| valnum = m104_6, r104_7, r105_3, r106_3
|
||||
# 105| r105_4(Base *) = ConvertToNonVirtualBase[Derived : Base] : r105_3
|
||||
# 105| valnum = m106_5, r105_4, r106_4, r107_3
|
||||
# 105| r105_5(glval<int>) = FieldAddress[b] : r105_4
|
||||
# 105| valnum = r105_5, r107_4
|
||||
# 105| r105_6(int) = Load : &:r105_5, ~m104_8
|
||||
# 105| r105_6(int) = Load[?] : &:r105_5, ~m104_8
|
||||
# 105| valnum = m105_7, m107_6, m109_4, r105_6, r107_5, r109_3
|
||||
# 105| m105_7(int) = Store : &:r105_1, r105_6
|
||||
# 105| m105_7(int) = Store[x] : &:r105_1, r105_6
|
||||
# 105| valnum = m105_7, m107_6, m109_4, r105_6, r107_5, r109_3
|
||||
# 106| r106_1(glval<Base *>) = VariableAddress[pb] :
|
||||
# 106| valnum = r106_1, r107_2
|
||||
# 106| r106_2(glval<Derived *>) = VariableAddress[pd] :
|
||||
# 106| valnum = r104_5, r105_2, r106_2
|
||||
# 106| r106_3(Derived *) = Load : &:r106_2, m104_6
|
||||
# 106| r106_3(Derived *) = Load[pd] : &:r106_2, m104_6
|
||||
# 106| valnum = m104_6, r104_7, r105_3, r106_3
|
||||
# 106| r106_4(Base *) = ConvertToNonVirtualBase[Derived : Base] : r106_3
|
||||
# 106| valnum = m106_5, r105_4, r106_4, r107_3
|
||||
# 106| m106_5(Base *) = Store : &:r106_1, r106_4
|
||||
# 106| m106_5(Base *) = Store[pb] : &:r106_1, r106_4
|
||||
# 106| valnum = m106_5, r105_4, r106_4, r107_3
|
||||
# 107| r107_1(glval<int>) = VariableAddress[y] :
|
||||
# 107| valnum = r107_1, r109_2
|
||||
# 107| r107_2(glval<Base *>) = VariableAddress[pb] :
|
||||
# 107| valnum = r106_1, r107_2
|
||||
# 107| r107_3(Base *) = Load : &:r107_2, m106_5
|
||||
# 107| r107_3(Base *) = Load[pb] : &:r107_2, m106_5
|
||||
# 107| valnum = m106_5, r105_4, r106_4, r107_3
|
||||
# 107| r107_4(glval<int>) = FieldAddress[b] : r107_3
|
||||
# 107| valnum = r105_5, r107_4
|
||||
# 107| r107_5(int) = Load : &:r107_4, ~m104_8
|
||||
# 107| r107_5(int) = Load[?] : &:r107_4, ~m104_8
|
||||
# 107| valnum = m105_7, m107_6, m109_4, r105_6, r107_5, r109_3
|
||||
# 107| m107_6(int) = Store : &:r107_1, r107_5
|
||||
# 107| m107_6(int) = Store[y] : &:r107_1, r107_5
|
||||
# 107| valnum = m105_7, m107_6, m109_4, r105_6, r107_5, r109_3
|
||||
# 109| r109_1(glval<int>) = VariableAddress[#return] :
|
||||
# 109| valnum = r104_10, r109_1
|
||||
# 109| r109_2(glval<int>) = VariableAddress[y] :
|
||||
# 109| valnum = r107_1, r109_2
|
||||
# 109| r109_3(int) = Load : &:r109_2, m107_6
|
||||
# 109| r109_3(int) = Load[y] : &:r109_2, m107_6
|
||||
# 109| valnum = m105_7, m107_6, m109_4, r105_6, r107_5, r109_3
|
||||
# 109| m109_4(int) = Store : &:r109_1, r109_3
|
||||
# 109| m109_4(int) = Store[#return] : &:r109_1, r109_3
|
||||
# 109| valnum = m105_7, m107_6, m109_4, r105_6, r107_5, r109_3
|
||||
# 104| v104_9(void) = ReturnIndirection[pd] : &:r104_7, m104_8
|
||||
# 104| r104_10(glval<int>) = VariableAddress[#return] :
|
||||
@@ -826,7 +826,7 @@ test.cpp:
|
||||
# 124| valnum = r124_5, r125_2, r126_2, r128_3, r129_2
|
||||
# 124| m124_6(A *) = InitializeParameter[pa] : &:r124_5
|
||||
# 124| valnum = m124_6, r124_7, r125_3, r126_3, r128_4, r129_3
|
||||
# 124| r124_7(A *) = Load : &:r124_5, m124_6
|
||||
# 124| r124_7(A *) = Load[pa] : &:r124_5, m124_6
|
||||
# 124| valnum = m124_6, r124_7, r125_3, r126_3, r128_4, r129_3
|
||||
# 124| m124_8(unknown) = InitializeIndirection[pa] : &:r124_7
|
||||
# 124| valnum = unique
|
||||
@@ -838,37 +838,37 @@ test.cpp:
|
||||
# 125| valnum = unique
|
||||
# 125| r125_2(glval<A *>) = VariableAddress[pa] :
|
||||
# 125| valnum = r124_5, r125_2, r126_2, r128_3, r129_2
|
||||
# 125| r125_3(A *) = Load : &:r125_2, m124_6
|
||||
# 125| r125_3(A *) = Load[pa] : &:r125_2, m124_6
|
||||
# 125| valnum = m124_6, r124_7, r125_3, r126_3, r128_4, r129_3
|
||||
# 125| r125_4(glval<int>) = FieldAddress[x] : r125_3
|
||||
# 125| valnum = r125_4, r126_4, r128_5, r129_4
|
||||
# 125| r125_5(int) = Load : &:r125_4, ~m124_8
|
||||
# 125| r125_5(int) = Load[?] : &:r125_4, ~m124_8
|
||||
# 125| valnum = m125_6, m126_6, r125_5, r126_5
|
||||
# 125| m125_6(int) = Store : &:r125_1, r125_5
|
||||
# 125| m125_6(int) = Store[b] : &:r125_1, r125_5
|
||||
# 125| valnum = m125_6, m126_6, r125_5, r126_5
|
||||
# 126| r126_1(glval<int>) = VariableAddress[c] :
|
||||
# 126| valnum = unique
|
||||
# 126| r126_2(glval<A *>) = VariableAddress[pa] :
|
||||
# 126| valnum = r124_5, r125_2, r126_2, r128_3, r129_2
|
||||
# 126| r126_3(A *) = Load : &:r126_2, m124_6
|
||||
# 126| r126_3(A *) = Load[pa] : &:r126_2, m124_6
|
||||
# 126| valnum = m124_6, r124_7, r125_3, r126_3, r128_4, r129_3
|
||||
# 126| r126_4(glval<int>) = FieldAddress[x] : r126_3
|
||||
# 126| valnum = r125_4, r126_4, r128_5, r129_4
|
||||
# 126| r126_5(int) = Load : &:r126_4, ~m124_8
|
||||
# 126| r126_5(int) = Load[?] : &:r126_4, ~m124_8
|
||||
# 126| valnum = m125_6, m126_6, r125_5, r126_5
|
||||
# 126| m126_6(int) = Store : &:r126_1, r126_5
|
||||
# 126| m126_6(int) = Store[c] : &:r126_1, r126_5
|
||||
# 126| valnum = m125_6, m126_6, r125_5, r126_5
|
||||
# 128| r128_1(glval<int>) = VariableAddress[n] :
|
||||
# 128| valnum = r124_9, r128_1
|
||||
# 128| r128_2(int) = Load : &:r128_1, m124_10
|
||||
# 128| r128_2(int) = Load[n] : &:r128_1, m124_10
|
||||
# 128| valnum = m124_10, m128_6, m129_6, r128_2, r129_5
|
||||
# 128| r128_3(glval<A *>) = VariableAddress[pa] :
|
||||
# 128| valnum = r124_5, r125_2, r126_2, r128_3, r129_2
|
||||
# 128| r128_4(A *) = Load : &:r128_3, m124_6
|
||||
# 128| r128_4(A *) = Load[pa] : &:r128_3, m124_6
|
||||
# 128| valnum = m124_6, r124_7, r125_3, r126_3, r128_4, r129_3
|
||||
# 128| r128_5(glval<int>) = FieldAddress[x] : r128_4
|
||||
# 128| valnum = r125_4, r126_4, r128_5, r129_4
|
||||
# 128| m128_6(int) = Store : &:r128_5, r128_2
|
||||
# 128| m128_6(int) = Store[?] : &:r128_5, r128_2
|
||||
# 128| valnum = m124_10, m128_6, m129_6, r128_2, r129_5
|
||||
# 128| m128_7(unknown) = Chi : total:m124_8, partial:m128_6
|
||||
# 128| valnum = unique
|
||||
@@ -876,13 +876,13 @@ test.cpp:
|
||||
# 129| valnum = unique
|
||||
# 129| r129_2(glval<A *>) = VariableAddress[pa] :
|
||||
# 129| valnum = r124_5, r125_2, r126_2, r128_3, r129_2
|
||||
# 129| r129_3(A *) = Load : &:r129_2, m124_6
|
||||
# 129| r129_3(A *) = Load[pa] : &:r129_2, m124_6
|
||||
# 129| valnum = m124_6, r124_7, r125_3, r126_3, r128_4, r129_3
|
||||
# 129| r129_4(glval<int>) = FieldAddress[x] : r129_3
|
||||
# 129| valnum = r125_4, r126_4, r128_5, r129_4
|
||||
# 129| r129_5(int) = Load : &:r129_4, m128_6
|
||||
# 129| r129_5(int) = Load[?] : &:r129_4, m128_6
|
||||
# 129| valnum = m124_10, m128_6, m129_6, r128_2, r129_5
|
||||
# 129| m129_6(int) = Store : &:r129_1, r129_5
|
||||
# 129| m129_6(int) = Store[d] : &:r129_1, r129_5
|
||||
# 129| valnum = m124_10, m128_6, m129_6, r128_2, r129_5
|
||||
# 130| v130_1(void) = NoOp :
|
||||
# 124| v124_11(void) = ReturnIndirection[pa] : &:r124_7, m128_7
|
||||
@@ -903,37 +903,37 @@ test.cpp:
|
||||
# 136| valnum = unique
|
||||
# 136| r136_2(glval<A *>) = VariableAddress[global_a] :
|
||||
# 136| valnum = r136_2, r137_2, r139_3, r140_2
|
||||
# 136| r136_3(A *) = Load : &:r136_2, ~m135_3
|
||||
# 136| r136_3(A *) = Load[global_a] : &:r136_2, ~m135_3
|
||||
# 136| valnum = r136_3, r137_3, r139_4
|
||||
# 136| r136_4(glval<int>) = FieldAddress[x] : r136_3
|
||||
# 136| valnum = r136_4, r137_4, r139_5
|
||||
# 136| r136_5(int) = Load : &:r136_4, ~m135_4
|
||||
# 136| r136_5(int) = Load[?] : &:r136_4, ~m135_4
|
||||
# 136| valnum = m136_6, m137_6, r136_5, r137_5
|
||||
# 136| m136_6(int) = Store : &:r136_1, r136_5
|
||||
# 136| m136_6(int) = Store[b] : &:r136_1, r136_5
|
||||
# 136| valnum = m136_6, m137_6, r136_5, r137_5
|
||||
# 137| r137_1(glval<int>) = VariableAddress[c] :
|
||||
# 137| valnum = unique
|
||||
# 137| r137_2(glval<A *>) = VariableAddress[global_a] :
|
||||
# 137| valnum = r136_2, r137_2, r139_3, r140_2
|
||||
# 137| r137_3(A *) = Load : &:r137_2, ~m135_3
|
||||
# 137| r137_3(A *) = Load[global_a] : &:r137_2, ~m135_3
|
||||
# 137| valnum = r136_3, r137_3, r139_4
|
||||
# 137| r137_4(glval<int>) = FieldAddress[x] : r137_3
|
||||
# 137| valnum = r136_4, r137_4, r139_5
|
||||
# 137| r137_5(int) = Load : &:r137_4, ~m135_4
|
||||
# 137| r137_5(int) = Load[?] : &:r137_4, ~m135_4
|
||||
# 137| valnum = m136_6, m137_6, r136_5, r137_5
|
||||
# 137| m137_6(int) = Store : &:r137_1, r137_5
|
||||
# 137| m137_6(int) = Store[c] : &:r137_1, r137_5
|
||||
# 137| valnum = m136_6, m137_6, r136_5, r137_5
|
||||
# 139| r139_1(glval<int>) = VariableAddress[global_n] :
|
||||
# 139| valnum = unique
|
||||
# 139| r139_2(int) = Load : &:r139_1, ~m135_3
|
||||
# 139| r139_2(int) = Load[global_n] : &:r139_1, ~m135_3
|
||||
# 139| valnum = m139_6, r139_2
|
||||
# 139| r139_3(glval<A *>) = VariableAddress[global_a] :
|
||||
# 139| valnum = r136_2, r137_2, r139_3, r140_2
|
||||
# 139| r139_4(A *) = Load : &:r139_3, ~m135_3
|
||||
# 139| r139_4(A *) = Load[global_a] : &:r139_3, ~m135_3
|
||||
# 139| valnum = r136_3, r137_3, r139_4
|
||||
# 139| r139_5(glval<int>) = FieldAddress[x] : r139_4
|
||||
# 139| valnum = r136_4, r137_4, r139_5
|
||||
# 139| m139_6(int) = Store : &:r139_5, r139_2
|
||||
# 139| m139_6(int) = Store[?] : &:r139_5, r139_2
|
||||
# 139| valnum = m139_6, r139_2
|
||||
# 139| m139_7(unknown) = Chi : total:m135_4, partial:m139_6
|
||||
# 139| valnum = unique
|
||||
@@ -941,13 +941,13 @@ test.cpp:
|
||||
# 140| valnum = unique
|
||||
# 140| r140_2(glval<A *>) = VariableAddress[global_a] :
|
||||
# 140| valnum = r136_2, r137_2, r139_3, r140_2
|
||||
# 140| r140_3(A *) = Load : &:r140_2, ~m139_7
|
||||
# 140| r140_3(A *) = Load[global_a] : &:r140_2, ~m139_7
|
||||
# 140| valnum = unique
|
||||
# 140| r140_4(glval<int>) = FieldAddress[x] : r140_3
|
||||
# 140| valnum = unique
|
||||
# 140| r140_5(int) = Load : &:r140_4, ~m139_7
|
||||
# 140| r140_5(int) = Load[?] : &:r140_4, ~m139_7
|
||||
# 140| valnum = m140_6, r140_5
|
||||
# 140| m140_6(int) = Store : &:r140_1, r140_5
|
||||
# 140| m140_6(int) = Store[d] : &:r140_1, r140_5
|
||||
# 140| valnum = m140_6, r140_5
|
||||
# 141| v141_1(void) = NoOp :
|
||||
# 135| v135_5(void) = ReturnVoid :
|
||||
@@ -967,7 +967,7 @@ test.cpp:
|
||||
# 143| valnum = r143_5, r144_2, r145_2, r147_3, r149_2
|
||||
# 143| m143_6(A *) = InitializeParameter[pa] : &:r143_5
|
||||
# 143| valnum = m143_6, r143_7, r144_3, r145_3, r147_4, r149_3
|
||||
# 143| r143_7(A *) = Load : &:r143_5, m143_6
|
||||
# 143| r143_7(A *) = Load[pa] : &:r143_5, m143_6
|
||||
# 143| valnum = m143_6, r143_7, r144_3, r145_3, r147_4, r149_3
|
||||
# 143| m143_8(unknown) = InitializeIndirection[pa] : &:r143_7
|
||||
# 143| valnum = unique
|
||||
@@ -975,37 +975,37 @@ test.cpp:
|
||||
# 144| valnum = unique
|
||||
# 144| r144_2(glval<A *>) = VariableAddress[pa] :
|
||||
# 144| valnum = r143_5, r144_2, r145_2, r147_3, r149_2
|
||||
# 144| r144_3(A *) = Load : &:r144_2, m143_6
|
||||
# 144| r144_3(A *) = Load[pa] : &:r144_2, m143_6
|
||||
# 144| valnum = m143_6, r143_7, r144_3, r145_3, r147_4, r149_3
|
||||
# 144| r144_4(glval<int>) = FieldAddress[x] : r144_3
|
||||
# 144| valnum = r144_4, r149_4
|
||||
# 144| r144_5(int) = Load : &:r144_4, ~m143_8
|
||||
# 144| r144_5(int) = Load[?] : &:r144_4, ~m143_8
|
||||
# 144| valnum = m144_6, m149_6, r144_5, r149_5
|
||||
# 144| m144_6(int) = Store : &:r144_1, r144_5
|
||||
# 144| m144_6(int) = Store[b] : &:r144_1, r144_5
|
||||
# 144| valnum = m144_6, m149_6, r144_5, r149_5
|
||||
# 145| r145_1(glval<int>) = VariableAddress[c] :
|
||||
# 145| valnum = unique
|
||||
# 145| r145_2(glval<A *>) = VariableAddress[pa] :
|
||||
# 145| valnum = r143_5, r144_2, r145_2, r147_3, r149_2
|
||||
# 145| r145_3(A *) = Load : &:r145_2, m143_6
|
||||
# 145| r145_3(A *) = Load[pa] : &:r145_2, m143_6
|
||||
# 145| valnum = m143_6, r143_7, r144_3, r145_3, r147_4, r149_3
|
||||
# 145| r145_4(glval<int>) = FieldAddress[y] : r145_3
|
||||
# 145| valnum = r145_4, r147_5
|
||||
# 145| r145_5(int) = Load : &:r145_4, ~m143_8
|
||||
# 145| r145_5(int) = Load[?] : &:r145_4, ~m143_8
|
||||
# 145| valnum = m145_6, r145_5
|
||||
# 145| m145_6(int) = Store : &:r145_1, r145_5
|
||||
# 145| m145_6(int) = Store[c] : &:r145_1, r145_5
|
||||
# 145| valnum = m145_6, r145_5
|
||||
# 147| r147_1(glval<int>) = VariableAddress[global_n] :
|
||||
# 147| valnum = unique
|
||||
# 147| r147_2(int) = Load : &:r147_1, ~m143_3
|
||||
# 147| r147_2(int) = Load[global_n] : &:r147_1, ~m143_3
|
||||
# 147| valnum = m147_6, r147_2
|
||||
# 147| r147_3(glval<A *>) = VariableAddress[pa] :
|
||||
# 147| valnum = r143_5, r144_2, r145_2, r147_3, r149_2
|
||||
# 147| r147_4(A *) = Load : &:r147_3, m143_6
|
||||
# 147| r147_4(A *) = Load[pa] : &:r147_3, m143_6
|
||||
# 147| valnum = m143_6, r143_7, r144_3, r145_3, r147_4, r149_3
|
||||
# 147| r147_5(glval<int>) = FieldAddress[y] : r147_4
|
||||
# 147| valnum = r145_4, r147_5
|
||||
# 147| m147_6(int) = Store : &:r147_5, r147_2
|
||||
# 147| m147_6(int) = Store[?] : &:r147_5, r147_2
|
||||
# 147| valnum = m147_6, r147_2
|
||||
# 147| m147_7(unknown) = Chi : total:m143_8, partial:m147_6
|
||||
# 147| valnum = unique
|
||||
@@ -1013,13 +1013,13 @@ test.cpp:
|
||||
# 149| valnum = unique
|
||||
# 149| r149_2(glval<A *>) = VariableAddress[pa] :
|
||||
# 149| valnum = r143_5, r144_2, r145_2, r147_3, r149_2
|
||||
# 149| r149_3(A *) = Load : &:r149_2, m143_6
|
||||
# 149| r149_3(A *) = Load[pa] : &:r149_2, m143_6
|
||||
# 149| valnum = m143_6, r143_7, r144_3, r145_3, r147_4, r149_3
|
||||
# 149| r149_4(glval<int>) = FieldAddress[x] : r149_3
|
||||
# 149| valnum = r144_4, r149_4
|
||||
# 149| r149_5(int) = Load : &:r149_4, ~m143_8
|
||||
# 149| r149_5(int) = Load[?] : &:r149_4, ~m143_8
|
||||
# 149| valnum = m144_6, m149_6, r144_5, r149_5
|
||||
# 149| m149_6(int) = Store : &:r149_1, r149_5
|
||||
# 149| m149_6(int) = Store[d] : &:r149_1, r149_5
|
||||
# 149| valnum = m144_6, m149_6, r144_5, r149_5
|
||||
# 150| v150_1(void) = NoOp :
|
||||
# 143| v143_9(void) = ReturnIndirection[pa] : &:r143_7, m147_7
|
||||
@@ -1044,37 +1044,37 @@ test.cpp:
|
||||
# 153| valnum = unique
|
||||
# 153| r153_2(glval<A *>) = VariableAddress[global_a] :
|
||||
# 153| valnum = r153_2, r154_2, r156_3, r158_2
|
||||
# 153| r153_3(A *) = Load : &:r153_2, ~m152_3
|
||||
# 153| r153_3(A *) = Load[global_a] : &:r153_2, ~m152_3
|
||||
# 153| valnum = r153_3, r154_3, r156_4
|
||||
# 153| r153_4(glval<int>) = FieldAddress[x] : r153_3
|
||||
# 153| valnum = r153_4, r154_4
|
||||
# 153| r153_5(int) = Load : &:r153_4, ~m152_4
|
||||
# 153| r153_5(int) = Load[?] : &:r153_4, ~m152_4
|
||||
# 153| valnum = m153_6, m154_6, r153_5, r154_5
|
||||
# 153| m153_6(int) = Store : &:r153_1, r153_5
|
||||
# 153| m153_6(int) = Store[b] : &:r153_1, r153_5
|
||||
# 153| valnum = m153_6, m154_6, r153_5, r154_5
|
||||
# 154| r154_1(glval<int>) = VariableAddress[c] :
|
||||
# 154| valnum = unique
|
||||
# 154| r154_2(glval<A *>) = VariableAddress[global_a] :
|
||||
# 154| valnum = r153_2, r154_2, r156_3, r158_2
|
||||
# 154| r154_3(A *) = Load : &:r154_2, ~m152_3
|
||||
# 154| r154_3(A *) = Load[global_a] : &:r154_2, ~m152_3
|
||||
# 154| valnum = r153_3, r154_3, r156_4
|
||||
# 154| r154_4(glval<int>) = FieldAddress[x] : r154_3
|
||||
# 154| valnum = r153_4, r154_4
|
||||
# 154| r154_5(int) = Load : &:r154_4, ~m152_4
|
||||
# 154| r154_5(int) = Load[?] : &:r154_4, ~m152_4
|
||||
# 154| valnum = m153_6, m154_6, r153_5, r154_5
|
||||
# 154| m154_6(int) = Store : &:r154_1, r154_5
|
||||
# 154| m154_6(int) = Store[c] : &:r154_1, r154_5
|
||||
# 154| valnum = m153_6, m154_6, r153_5, r154_5
|
||||
# 156| r156_1(glval<int>) = VariableAddress[n] :
|
||||
# 156| valnum = r152_5, r156_1
|
||||
# 156| r156_2(int) = Load : &:r156_1, m152_6
|
||||
# 156| r156_2(int) = Load[n] : &:r156_1, m152_6
|
||||
# 156| valnum = m152_6, m156_6, r156_2
|
||||
# 156| r156_3(glval<A *>) = VariableAddress[global_a] :
|
||||
# 156| valnum = r153_2, r154_2, r156_3, r158_2
|
||||
# 156| r156_4(A *) = Load : &:r156_3, ~m152_3
|
||||
# 156| r156_4(A *) = Load[global_a] : &:r156_3, ~m152_3
|
||||
# 156| valnum = r153_3, r154_3, r156_4
|
||||
# 156| r156_5(glval<int>) = FieldAddress[y] : r156_4
|
||||
# 156| valnum = unique
|
||||
# 156| m156_6(int) = Store : &:r156_5, r156_2
|
||||
# 156| m156_6(int) = Store[?] : &:r156_5, r156_2
|
||||
# 156| valnum = m152_6, m156_6, r156_2
|
||||
# 156| m156_7(unknown) = Chi : total:m152_4, partial:m156_6
|
||||
# 156| valnum = unique
|
||||
@@ -1082,13 +1082,13 @@ test.cpp:
|
||||
# 158| valnum = unique
|
||||
# 158| r158_2(glval<A *>) = VariableAddress[global_a] :
|
||||
# 158| valnum = r153_2, r154_2, r156_3, r158_2
|
||||
# 158| r158_3(A *) = Load : &:r158_2, ~m156_7
|
||||
# 158| r158_3(A *) = Load[global_a] : &:r158_2, ~m156_7
|
||||
# 158| valnum = unique
|
||||
# 158| r158_4(glval<int>) = FieldAddress[x] : r158_3
|
||||
# 158| valnum = unique
|
||||
# 158| r158_5(int) = Load : &:r158_4, ~m156_7
|
||||
# 158| r158_5(int) = Load[?] : &:r158_4, ~m156_7
|
||||
# 158| valnum = m158_6, r158_5
|
||||
# 158| m158_6(int) = Store : &:r158_1, r158_5
|
||||
# 158| m158_6(int) = Store[d] : &:r158_1, r158_5
|
||||
# 158| valnum = m158_6, r158_5
|
||||
# 159| v159_1(void) = NoOp :
|
||||
# 152| v152_7(void) = ReturnVoid :
|
||||
|
||||
@@ -804,12 +804,26 @@ class CopyValueInstruction extends CopyInstruction, UnaryInstruction {
|
||||
final override UnaryOperand getSourceValueOperand() { result = getAnOperand() }
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a string describing the location pointed to by the specified address operand.
|
||||
*/
|
||||
private string getAddressOperandDescription(AddressOperand operand) {
|
||||
result = operand.getDef().(VariableAddressInstruction).getIRVariable().toString()
|
||||
or
|
||||
not operand.getDef() instanceof VariableAddressInstruction and
|
||||
result = "?"
|
||||
}
|
||||
|
||||
/**
|
||||
* An instruction that returns a register result containing a copy of its memory operand.
|
||||
*/
|
||||
class LoadInstruction extends CopyInstruction {
|
||||
LoadInstruction() { getOpcode() instanceof Opcode::Load }
|
||||
|
||||
final override string getImmediateString() {
|
||||
result = getAddressOperandDescription(getSourceAddressOperand())
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the operand that provides the address of the value being loaded.
|
||||
*/
|
||||
@@ -829,6 +843,10 @@ class LoadInstruction extends CopyInstruction {
|
||||
class StoreInstruction extends CopyInstruction {
|
||||
StoreInstruction() { getOpcode() instanceof Opcode::Store }
|
||||
|
||||
final override string getImmediateString() {
|
||||
result = getAddressOperandDescription(getDestinationAddressOperand())
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the operand that provides the address of the location to which the value will be stored.
|
||||
*/
|
||||
|
||||
@@ -804,12 +804,26 @@ class CopyValueInstruction extends CopyInstruction, UnaryInstruction {
|
||||
final override UnaryOperand getSourceValueOperand() { result = getAnOperand() }
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a string describing the location pointed to by the specified address operand.
|
||||
*/
|
||||
private string getAddressOperandDescription(AddressOperand operand) {
|
||||
result = operand.getDef().(VariableAddressInstruction).getIRVariable().toString()
|
||||
or
|
||||
not operand.getDef() instanceof VariableAddressInstruction and
|
||||
result = "?"
|
||||
}
|
||||
|
||||
/**
|
||||
* An instruction that returns a register result containing a copy of its memory operand.
|
||||
*/
|
||||
class LoadInstruction extends CopyInstruction {
|
||||
LoadInstruction() { getOpcode() instanceof Opcode::Load }
|
||||
|
||||
final override string getImmediateString() {
|
||||
result = getAddressOperandDescription(getSourceAddressOperand())
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the operand that provides the address of the value being loaded.
|
||||
*/
|
||||
@@ -829,6 +843,10 @@ class LoadInstruction extends CopyInstruction {
|
||||
class StoreInstruction extends CopyInstruction {
|
||||
StoreInstruction() { getOpcode() instanceof Opcode::Store }
|
||||
|
||||
final override string getImmediateString() {
|
||||
result = getAddressOperandDescription(getDestinationAddressOperand())
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the operand that provides the address of the location to which the value will be stored.
|
||||
*/
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user