mirror of
https://github.com/github/codeql.git
synced 2026-04-30 19:26:02 +02:00
C++: IR sanity fixes for Chi nodes
This commit is contained in:
Robert Marsh
committed by
Dave Bartolomeo
Dave Bartolomeo
parent
b401cd97f2
commit
3ee033d96e
@@ -43,6 +43,10 @@ cached private module Cached {
|
||||
getOldInstruction(result) = instr
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the chi node corresponding to `instr` if one is present, or the new `Instruction`
|
||||
* corresponding to `instr` if there is no `Chi` node.
|
||||
*/
|
||||
private Instruction getNewFinalInstruction(OldIR::Instruction instr) {
|
||||
result = getChiInstruction(instr)
|
||||
or
|
||||
@@ -202,12 +206,15 @@ cached private module Cached {
|
||||
cached Instruction getChiInstructionTotalOperand(ChiInstruction chiInstr, ChiTotalOperandTag tag) {
|
||||
exists(Alias::VirtualVariable vvar, OldIR::Instruction oldInstr, OldIR::IRBlock defBlock,
|
||||
int defRank, int defIndex, OldIR::IRBlock useBlock, int useRank |
|
||||
ChiTag(oldInstr) = chiInstr.getTag() and
|
||||
vvar = Alias::getResultMemoryAccess(oldInstr).getVirtualVariable() and
|
||||
hasDefinitionAtRank(vvar, defBlock, defRank, defIndex) and
|
||||
hasUseAtRank(vvar, useBlock, useRank, oldInstr) and
|
||||
definitionReachesUse(vvar, defBlock, defRank, useBlock, useRank) and
|
||||
result = getNewFinalInstruction(defBlock.getInstruction(defIndex))
|
||||
ChiTag(oldInstr) = chiInstr.getTag() and
|
||||
vvar = Alias::getResultMemoryAccess(oldInstr).getVirtualVariable() and
|
||||
hasDefinitionAtRank(vvar, defBlock, defRank, defIndex) and
|
||||
hasUseAtRank(vvar, useBlock, useRank, oldInstr) and
|
||||
definitionReachesUse(vvar, defBlock, defRank, useBlock, useRank) and
|
||||
if defIndex >= 0 then
|
||||
result = getNewFinalInstruction(defBlock.getInstruction(defIndex))
|
||||
else
|
||||
result = getPhiInstruction(chiInstr.getFunction(), defBlock, vvar)
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
@@ -62,6 +62,7 @@ newtype TInstructionTag =
|
||||
CatchTag() or
|
||||
ThrowTag() or
|
||||
UnwindTag() or
|
||||
InitializerUninitializedTag() or
|
||||
InitializerFieldAddressTag(Field field) {
|
||||
fieldIsInitialized(field)
|
||||
} or
|
||||
|
||||
@@ -38,142 +38,6 @@
|
||||
#-----| Type = unsigned long
|
||||
#-----| 1: p#1
|
||||
#-----| Type = align_val_t
|
||||
bad_asts.cpp:
|
||||
# 5| Bad::S::operator=(S &&) -> S &
|
||||
# 5| params:
|
||||
#-----| 0: p#0
|
||||
#-----| Type = S &&
|
||||
# 5| Bad::S::operator=(const S &) -> S &
|
||||
# 5| params:
|
||||
#-----| 0: p#0
|
||||
#-----| Type = const S &
|
||||
# 9| Bad::S::MemberFunction(int) -> int
|
||||
# 9| params:
|
||||
# 9| 0: y
|
||||
# 9| Type = int
|
||||
# 9| body: { ... }
|
||||
# 10| 0: return ...
|
||||
# 10| 0: ... + ...
|
||||
# 10| Type = int
|
||||
# 10| ValueCategory = prvalue
|
||||
# 10| 0: ... + ...
|
||||
# 10| Type = int
|
||||
# 10| ValueCategory = prvalue
|
||||
# 10| 0: Unknown literal
|
||||
# 10| Type = int
|
||||
# 10| ValueCategory = prvalue
|
||||
# 10| 1: x
|
||||
# 10| Type = int
|
||||
# 10| ValueCategory = prvalue(load)
|
||||
#-----| -1: this
|
||||
#-----| Type = S *
|
||||
#-----| ValueCategory = prvalue(load)
|
||||
# 10| 1: y
|
||||
# 10| Type = int
|
||||
# 10| ValueCategory = prvalue(load)
|
||||
# 9| MemberFunction(int) -> int
|
||||
# 9| params:
|
||||
# 9| 0: y
|
||||
# 9| Type = int
|
||||
# 9| body: { ... }
|
||||
# 10| 0: return ...
|
||||
# 10| 0: ... + ...
|
||||
# 10| Type = int
|
||||
# 10| ValueCategory = prvalue
|
||||
# 10| 0: ... + ...
|
||||
# 10| Type = int
|
||||
# 10| ValueCategory = prvalue
|
||||
# 10| 0: 6
|
||||
# 10| Type = int
|
||||
# 10| Value = 6
|
||||
# 10| ValueCategory = prvalue
|
||||
# 10| 1: x
|
||||
# 10| Type = int
|
||||
# 10| ValueCategory = prvalue(load)
|
||||
#-----| -1: this
|
||||
#-----| Type = S *
|
||||
#-----| ValueCategory = prvalue(load)
|
||||
# 10| 1: y
|
||||
# 10| Type = int
|
||||
# 10| ValueCategory = prvalue(load)
|
||||
# 14| Bad::CallBadMemberFunction() -> void
|
||||
# 14| params:
|
||||
# 14| body: { ... }
|
||||
# 15| 0: declaration
|
||||
# 15| 0: definition of s
|
||||
# 15| Type = S
|
||||
# 15| init: initializer for s
|
||||
# 15| expr: {...}
|
||||
# 15| Type = S
|
||||
# 15| ValueCategory = prvalue
|
||||
# 16| 1: ExprStmt
|
||||
# 16| 0: call to MemberFunction
|
||||
# 16| Type = int
|
||||
# 16| ValueCategory = prvalue
|
||||
# 16| -1: s
|
||||
# 16| Type = S
|
||||
# 16| ValueCategory = lvalue
|
||||
# 16| 0: 1
|
||||
# 16| Type = int
|
||||
# 16| Value = 1
|
||||
# 16| ValueCategory = prvalue
|
||||
# 17| 2: return ...
|
||||
# 19| Bad::Point::Point(Point &&) -> void
|
||||
# 19| params:
|
||||
#-----| 0: p#0
|
||||
#-----| Type = Point &&
|
||||
# 19| Bad::Point::Point(const Point &) -> void
|
||||
# 19| params:
|
||||
#-----| 0: p#0
|
||||
#-----| Type = const Point &
|
||||
# 19| initializations:
|
||||
# 19| 0: constructor init of field x
|
||||
# 19| Type = int
|
||||
# 19| ValueCategory = prvalue
|
||||
# 19| 0: Unknown literal
|
||||
# 19| Type = int
|
||||
# 19| ValueCategory = prvalue
|
||||
# 19| 1: constructor init of field y
|
||||
# 19| Type = int
|
||||
# 19| ValueCategory = prvalue
|
||||
# 19| 0: Unknown literal
|
||||
# 19| Type = int
|
||||
# 19| ValueCategory = prvalue
|
||||
# 19| body: { ... }
|
||||
# 19| 0: return ...
|
||||
# 19| Bad::Point::operator=(Point &&) -> Point &
|
||||
# 19| params:
|
||||
#-----| 0: p#0
|
||||
#-----| Type = Point &&
|
||||
# 19| Bad::Point::operator=(const Point &) -> Point &
|
||||
# 19| params:
|
||||
#-----| 0: p#0
|
||||
#-----| Type = const Point &
|
||||
# 22| Bad::Point::Point() -> void
|
||||
# 22| params:
|
||||
# 22| initializations:
|
||||
# 22| body: { ... }
|
||||
# 23| 0: return ...
|
||||
# 26| Bad::CallCopyConstructor(const Point &) -> void
|
||||
# 26| params:
|
||||
# 26| 0: a
|
||||
# 26| Type = const Point &
|
||||
# 26| body: { ... }
|
||||
# 27| 0: declaration
|
||||
# 27| 0: definition of b
|
||||
# 27| Type = Point
|
||||
# 27| init: initializer for b
|
||||
# 27| expr: (Point)...
|
||||
# 27| Conversion = glvalue conversion
|
||||
# 27| Type = Point
|
||||
# 27| ValueCategory = prvalue(load)
|
||||
# 27| expr: (reference dereference)
|
||||
# 27| Type = const Point
|
||||
# 27| ValueCategory = lvalue
|
||||
# 27| expr: a
|
||||
# 27| Type = const Point &
|
||||
# 27| ValueCategory = prvalue(load)
|
||||
# 28| 1: return ...
|
||||
ir.cpp:
|
||||
# 1| Constants() -> void
|
||||
# 1| params:
|
||||
@@ -6475,119 +6339,80 @@ ir.cpp:
|
||||
# 963| Type = int
|
||||
# 963| Value = 900
|
||||
# 963| ValueCategory = prvalue
|
||||
# 966| IfStmtWithDeclaration(int, int) -> void
|
||||
# 966| params:
|
||||
# 966| 0: x
|
||||
# 966| Type = int
|
||||
# 966| 1: y
|
||||
# 966| Type = int
|
||||
# 966| body: { ... }
|
||||
# 967| 0: if (...) ...
|
||||
# 967| 0: (condition decl)
|
||||
# 967| Type = bool
|
||||
# 967| ValueCategory = prvalue
|
||||
# 967| 0: b
|
||||
# 967| Type = bool
|
||||
# 967| ValueCategory = prvalue(load)
|
||||
# 967| 1: { ... }
|
||||
# 968| 0: ExprStmt
|
||||
# 968| 0: ... = ...
|
||||
# 968| Type = int
|
||||
# 968| ValueCategory = lvalue
|
||||
# 968| 0: x
|
||||
# 968| Type = int
|
||||
# 968| ValueCategory = lvalue
|
||||
# 968| 1: 5
|
||||
# 968| Type = int
|
||||
# 968| Value = 5
|
||||
# 968| ValueCategory = prvalue
|
||||
# 970| 2: if (...) ...
|
||||
# 970| 0: (condition decl)
|
||||
# 970| Type = bool
|
||||
# 970| ValueCategory = prvalue
|
||||
# 970| 0: (bool)...
|
||||
# 970| Conversion = conversion to bool
|
||||
# 970| Type = bool
|
||||
# 970| ValueCategory = prvalue
|
||||
# 970| expr: z
|
||||
# 970| Type = int
|
||||
# 970| ValueCategory = prvalue(load)
|
||||
# 970| 1: { ... }
|
||||
# 971| 0: ExprStmt
|
||||
# 971| 0: ... = ...
|
||||
# 971| Type = int
|
||||
# 971| ValueCategory = lvalue
|
||||
# 971| 0: y
|
||||
# 971| Type = int
|
||||
# 971| ValueCategory = lvalue
|
||||
# 971| 1: 7
|
||||
# 971| Type = int
|
||||
# 971| Value = 7
|
||||
# 971| ValueCategory = prvalue
|
||||
# 973| 2: if (...) ...
|
||||
# 973| 0: (condition decl)
|
||||
# 973| Type = bool
|
||||
# 973| ValueCategory = prvalue
|
||||
# 973| 0: (bool)...
|
||||
# 973| Conversion = conversion to bool
|
||||
# 973| Type = bool
|
||||
# 973| ValueCategory = prvalue
|
||||
# 973| expr: p
|
||||
# 973| Type = int *
|
||||
# 973| ValueCategory = prvalue(load)
|
||||
# 973| 1: { ... }
|
||||
# 974| 0: ExprStmt
|
||||
# 974| 0: ... = ...
|
||||
# 974| Type = int
|
||||
# 974| ValueCategory = lvalue
|
||||
# 974| 0: * ...
|
||||
# 974| Type = int
|
||||
# 974| ValueCategory = lvalue
|
||||
# 974| 0: p
|
||||
# 974| Type = int *
|
||||
# 974| ValueCategory = prvalue(load)
|
||||
# 974| 1: 2
|
||||
# 974| Type = int
|
||||
# 974| Value = 2
|
||||
# 974| ValueCategory = prvalue
|
||||
# 976| 1: return ...
|
||||
# 978| WhileStmtWithDeclaration(int, int) -> void
|
||||
# 978| params:
|
||||
# 978| 0: x
|
||||
# 978| Type = int
|
||||
# 978| 1: y
|
||||
# 978| Type = int
|
||||
# 978| body: { ... }
|
||||
# 979| 0: while (...) ...
|
||||
# 979| 0: (condition decl)
|
||||
# 979| Type = bool
|
||||
# 979| ValueCategory = prvalue
|
||||
# 979| 0: b
|
||||
# 979| Type = bool
|
||||
# 979| ValueCategory = prvalue(load)
|
||||
# 979| 1: { ... }
|
||||
# 981| 1: while (...) ...
|
||||
# 981| 0: (condition decl)
|
||||
# 981| Type = bool
|
||||
# 981| ValueCategory = prvalue
|
||||
# 981| 0: (bool)...
|
||||
# 981| Conversion = conversion to bool
|
||||
# 981| Type = bool
|
||||
# 981| ValueCategory = prvalue
|
||||
# 981| expr: z
|
||||
# 981| Type = int
|
||||
# 981| ValueCategory = prvalue(load)
|
||||
# 981| 1: { ... }
|
||||
# 983| 2: while (...) ...
|
||||
# 983| 0: (condition decl)
|
||||
# 983| Type = bool
|
||||
# 983| ValueCategory = prvalue
|
||||
# 983| 0: (bool)...
|
||||
# 983| Conversion = conversion to bool
|
||||
# 983| Type = bool
|
||||
# 983| ValueCategory = prvalue
|
||||
# 983| expr: p
|
||||
# 983| Type = int *
|
||||
# 983| ValueCategory = prvalue(load)
|
||||
# 983| 1: { ... }
|
||||
# 985| 3: return ...
|
||||
# 984| ChiPhiNode(Point *, bool, bool) -> int
|
||||
# 984| params:
|
||||
# 984| 0: p
|
||||
# 984| Type = Point *
|
||||
# 984| 1: which1
|
||||
# 984| Type = bool
|
||||
# 984| 2: which2
|
||||
# 984| Type = bool
|
||||
# 984| body: { ... }
|
||||
# 985| 0: if (...) ...
|
||||
# 985| 0: which1
|
||||
# 985| Type = bool
|
||||
# 985| ValueCategory = prvalue(load)
|
||||
# 985| 1: { ... }
|
||||
# 986| 0: ExprStmt
|
||||
# 986| 0: ... ++
|
||||
# 986| Type = int
|
||||
# 986| ValueCategory = prvalue
|
||||
# 986| 0: x
|
||||
# 986| Type = int
|
||||
# 986| ValueCategory = lvalue
|
||||
# 986| -1: p
|
||||
# 986| Type = Point *
|
||||
# 986| ValueCategory = prvalue(load)
|
||||
# 987| 2: { ... }
|
||||
# 988| 0: ExprStmt
|
||||
# 988| 0: ... ++
|
||||
# 988| Type = int
|
||||
# 988| ValueCategory = prvalue
|
||||
# 988| 0: y
|
||||
# 988| Type = int
|
||||
# 988| ValueCategory = lvalue
|
||||
# 988| -1: p
|
||||
# 988| Type = Point *
|
||||
# 988| ValueCategory = prvalue(load)
|
||||
# 991| 1: if (...) ...
|
||||
# 991| 0: which2
|
||||
# 991| Type = bool
|
||||
# 991| ValueCategory = prvalue(load)
|
||||
# 991| 1: { ... }
|
||||
# 992| 0: ExprStmt
|
||||
# 992| 0: ... ++
|
||||
# 992| Type = int
|
||||
# 992| ValueCategory = prvalue
|
||||
# 992| 0: x
|
||||
# 992| Type = int
|
||||
# 992| ValueCategory = lvalue
|
||||
# 992| -1: p
|
||||
# 992| Type = Point *
|
||||
# 992| ValueCategory = prvalue(load)
|
||||
# 993| 2: { ... }
|
||||
# 994| 0: ExprStmt
|
||||
# 994| 0: ... ++
|
||||
# 994| Type = int
|
||||
# 994| ValueCategory = prvalue
|
||||
# 994| 0: y
|
||||
# 994| Type = int
|
||||
# 994| ValueCategory = lvalue
|
||||
# 994| -1: p
|
||||
# 994| Type = Point *
|
||||
# 994| ValueCategory = prvalue(load)
|
||||
# 997| 2: return ...
|
||||
# 997| 0: ... + ...
|
||||
# 997| Type = int
|
||||
# 997| ValueCategory = prvalue
|
||||
# 997| 0: x
|
||||
# 997| Type = int
|
||||
# 997| ValueCategory = prvalue(load)
|
||||
# 997| -1: p
|
||||
# 997| Type = Point *
|
||||
# 997| ValueCategory = prvalue(load)
|
||||
# 997| 1: y
|
||||
# 997| Type = int
|
||||
# 997| ValueCategory = prvalue(load)
|
||||
# 997| -1: p
|
||||
# 997| Type = Point *
|
||||
# 997| ValueCategory = prvalue(load)
|
||||
|
||||
@@ -2173,46 +2173,49 @@ ir.cpp:
|
||||
# 503| r0_4(glval<float>) = VariableAddress[f] :
|
||||
# 503| m0_5(float) = InitializeParameter[f] : r0_4
|
||||
# 504| r0_6(glval<Point>) = VariableAddress[pt1] :
|
||||
# 504| r0_7(glval<int>) = FieldAddress[x] : r0_6
|
||||
# 504| r0_8(glval<int>) = VariableAddress[x] :
|
||||
# 504| r0_9(int) = Load : r0_8, m0_3
|
||||
# 504| m0_10(int) = Store : r0_7, r0_9
|
||||
# 504| m0_11(Point) = Chi : m0_10
|
||||
# 504| r0_12(glval<int>) = FieldAddress[y] : r0_6
|
||||
# 504| r0_13(glval<float>) = VariableAddress[f] :
|
||||
# 504| r0_14(float) = Load : r0_13, m0_5
|
||||
# 504| r0_15(int) = Convert : r0_14
|
||||
# 504| m0_16(int) = Store : r0_12, r0_15
|
||||
# 504| m0_17(Point) = Chi : m0_11, m0_16
|
||||
# 505| r0_18(glval<Point>) = VariableAddress[pt2] :
|
||||
# 505| r0_19(glval<int>) = FieldAddress[x] : r0_18
|
||||
# 505| r0_20(glval<int>) = VariableAddress[x] :
|
||||
# 505| r0_21(int) = Load : r0_20, m0_3
|
||||
# 505| m0_22(int) = Store : r0_19, r0_21
|
||||
# 505| m0_23(Point) = Chi : m0_22
|
||||
# 505| r0_24(glval<int>) = FieldAddress[y] : r0_18
|
||||
# 505| r0_25(int) = Constant[0] :
|
||||
# 505| m0_26(int) = Store : r0_24, r0_25
|
||||
# 505| m0_27(Point) = Chi : m0_23, m0_26
|
||||
# 506| r0_28(glval<Point>) = VariableAddress[pt3] :
|
||||
# 506| r0_29(glval<int>) = FieldAddress[x] : r0_28
|
||||
# 506| r0_30(int) = Constant[0] :
|
||||
# 506| m0_31(int) = Store : r0_29, r0_30
|
||||
# 506| m0_32(Point) = Chi : m0_31
|
||||
# 506| r0_33(glval<int>) = FieldAddress[y] : r0_28
|
||||
# 506| r0_34(int) = Constant[0] :
|
||||
# 506| m0_35(int) = Store : r0_33, r0_34
|
||||
# 506| m0_36(Point) = Chi : m0_32, m0_35
|
||||
# 508| r0_37(glval<int>) = VariableAddress[x1] :
|
||||
# 508| r0_38(int) = Constant[1] :
|
||||
# 508| m0_39(int) = Store : r0_37, r0_38
|
||||
# 509| r0_40(glval<int>) = VariableAddress[x2] :
|
||||
# 509| r0_41(int) = Constant[0] :
|
||||
# 509| m0_42(int) = Store : r0_40, r0_41
|
||||
# 510| v0_43(void) = NoOp :
|
||||
# 503| v0_44(void) = ReturnVoid :
|
||||
# 503| v0_45(void) = UnmodeledUse : mu*
|
||||
# 503| v0_46(void) = ExitFunction :
|
||||
# 504| m0_7(Point) = Uninitialized : r0_6
|
||||
# 504| r0_8(glval<int>) = FieldAddress[x] : r0_6
|
||||
# 504| r0_9(glval<int>) = VariableAddress[x] :
|
||||
# 504| r0_10(int) = Load : r0_9, m0_3
|
||||
# 504| m0_11(int) = Store : r0_8, r0_10
|
||||
# 504| m0_12(Point) = Chi : m0_7, m0_11
|
||||
# 504| r0_13(glval<int>) = FieldAddress[y] : r0_6
|
||||
# 504| r0_14(glval<float>) = VariableAddress[f] :
|
||||
# 504| r0_15(float) = Load : r0_14, m0_5
|
||||
# 504| r0_16(int) = Convert : r0_15
|
||||
# 504| m0_17(int) = Store : r0_13, r0_16
|
||||
# 504| m0_18(Point) = Chi : m0_12, m0_17
|
||||
# 505| r0_19(glval<Point>) = VariableAddress[pt2] :
|
||||
# 505| m0_20(Point) = Uninitialized : r0_19
|
||||
# 505| r0_21(glval<int>) = FieldAddress[x] : r0_19
|
||||
# 505| r0_22(glval<int>) = VariableAddress[x] :
|
||||
# 505| r0_23(int) = Load : r0_22, m0_3
|
||||
# 505| m0_24(int) = Store : r0_21, r0_23
|
||||
# 505| m0_25(Point) = Chi : m0_20, m0_24
|
||||
# 505| r0_26(glval<int>) = FieldAddress[y] : r0_19
|
||||
# 505| r0_27(int) = Constant[0] :
|
||||
# 505| m0_28(int) = Store : r0_26, r0_27
|
||||
# 505| m0_29(Point) = Chi : m0_25, m0_28
|
||||
# 506| r0_30(glval<Point>) = VariableAddress[pt3] :
|
||||
# 506| m0_31(Point) = Uninitialized : r0_30
|
||||
# 506| r0_32(glval<int>) = FieldAddress[x] : r0_30
|
||||
# 506| r0_33(int) = Constant[0] :
|
||||
# 506| m0_34(int) = Store : r0_32, r0_33
|
||||
# 506| m0_35(Point) = Chi : m0_31, m0_34
|
||||
# 506| r0_36(glval<int>) = FieldAddress[y] : r0_30
|
||||
# 506| r0_37(int) = Constant[0] :
|
||||
# 506| m0_38(int) = Store : r0_36, r0_37
|
||||
# 506| m0_39(Point) = Chi : m0_35, m0_38
|
||||
# 508| r0_40(glval<int>) = VariableAddress[x1] :
|
||||
# 508| r0_41(int) = Constant[1] :
|
||||
# 508| m0_42(int) = Store : r0_40, r0_41
|
||||
# 509| r0_43(glval<int>) = VariableAddress[x2] :
|
||||
# 509| r0_44(int) = Constant[0] :
|
||||
# 509| m0_45(int) = Store : r0_43, r0_44
|
||||
# 510| v0_46(void) = NoOp :
|
||||
# 503| v0_47(void) = ReturnVoid :
|
||||
# 503| v0_48(void) = UnmodeledUse : mu*
|
||||
# 503| v0_49(void) = ExitFunction :
|
||||
|
||||
# 512| NestedInitList(int, float) -> void
|
||||
# 512| Block 0
|
||||
@@ -2223,81 +2226,85 @@ ir.cpp:
|
||||
# 512| r0_4(glval<float>) = VariableAddress[f] :
|
||||
# 512| m0_5(float) = InitializeParameter[f] : r0_4
|
||||
# 513| r0_6(glval<Rect>) = VariableAddress[r1] :
|
||||
# 513| r0_7(glval<Point>) = FieldAddress[topLeft] : r0_6
|
||||
# 513| r0_8(Point) = Constant[0] :
|
||||
# 513| m0_9(Point) = Store : r0_7, r0_8
|
||||
# 513| m0_10(Rect) = Chi : m0_9
|
||||
# 513| r0_11(glval<Point>) = FieldAddress[bottomRight] : r0_6
|
||||
# 513| r0_12(Point) = Constant[0] :
|
||||
# 513| m0_13(Point) = Store : r0_11, r0_12
|
||||
# 513| m0_14(Rect) = Chi : m0_10, m0_13
|
||||
# 514| r0_15(glval<Rect>) = VariableAddress[r2] :
|
||||
# 514| r0_16(glval<Point>) = FieldAddress[topLeft] : r0_15
|
||||
# 514| r0_17(glval<int>) = FieldAddress[x] : r0_16
|
||||
# 514| r0_18(glval<int>) = VariableAddress[x] :
|
||||
# 514| r0_19(int) = Load : r0_18, m0_3
|
||||
# 514| m0_20(int) = Store : r0_17, r0_19
|
||||
# 514| m0_21(Rect) = Chi : m0_20
|
||||
# 514| r0_22(glval<int>) = FieldAddress[y] : r0_16
|
||||
# 514| r0_23(glval<float>) = VariableAddress[f] :
|
||||
# 514| r0_24(float) = Load : r0_23, m0_5
|
||||
# 514| r0_25(int) = Convert : r0_24
|
||||
# 514| m0_26(int) = Store : r0_22, r0_25
|
||||
# 514| m0_27(Rect) = Chi : m0_21, m0_26
|
||||
# 514| r0_28(glval<Point>) = FieldAddress[bottomRight] : r0_15
|
||||
# 514| r0_29(Point) = Constant[0] :
|
||||
# 514| m0_30(Point) = Store : r0_28, r0_29
|
||||
# 514| m0_31(Rect) = Chi : m0_27, m0_30
|
||||
# 515| r0_32(glval<Rect>) = VariableAddress[r3] :
|
||||
# 515| r0_33(glval<Point>) = FieldAddress[topLeft] : r0_32
|
||||
# 515| r0_34(glval<int>) = FieldAddress[x] : r0_33
|
||||
# 515| r0_35(glval<int>) = VariableAddress[x] :
|
||||
# 515| r0_36(int) = Load : r0_35, m0_3
|
||||
# 515| m0_37(int) = Store : r0_34, r0_36
|
||||
# 515| m0_38(Rect) = Chi : m0_37
|
||||
# 515| r0_39(glval<int>) = FieldAddress[y] : r0_33
|
||||
# 515| r0_40(glval<float>) = VariableAddress[f] :
|
||||
# 515| r0_41(float) = Load : r0_40, m0_5
|
||||
# 515| r0_42(int) = Convert : r0_41
|
||||
# 515| m0_43(int) = Store : r0_39, r0_42
|
||||
# 515| m0_44(Rect) = Chi : m0_38, m0_43
|
||||
# 515| r0_45(glval<Point>) = FieldAddress[bottomRight] : r0_32
|
||||
# 515| r0_46(glval<int>) = FieldAddress[x] : r0_45
|
||||
# 515| r0_47(glval<int>) = VariableAddress[x] :
|
||||
# 515| r0_48(int) = Load : r0_47, m0_3
|
||||
# 515| m0_49(int) = Store : r0_46, r0_48
|
||||
# 515| m0_50(Rect) = Chi : m0_44, m0_49
|
||||
# 515| r0_51(glval<int>) = FieldAddress[y] : r0_45
|
||||
# 515| r0_52(glval<float>) = VariableAddress[f] :
|
||||
# 515| r0_53(float) = Load : r0_52, m0_5
|
||||
# 515| r0_54(int) = Convert : r0_53
|
||||
# 515| m0_55(int) = Store : r0_51, r0_54
|
||||
# 515| m0_56(Rect) = Chi : m0_50, m0_55
|
||||
# 516| r0_57(glval<Rect>) = VariableAddress[r4] :
|
||||
# 516| r0_58(glval<Point>) = FieldAddress[topLeft] : r0_57
|
||||
# 516| r0_59(glval<int>) = FieldAddress[x] : r0_58
|
||||
# 516| r0_60(glval<int>) = VariableAddress[x] :
|
||||
# 516| r0_61(int) = Load : r0_60, m0_3
|
||||
# 516| m0_62(int) = Store : r0_59, r0_61
|
||||
# 516| m0_63(Rect) = Chi : m0_62
|
||||
# 516| r0_64(glval<int>) = FieldAddress[y] : r0_58
|
||||
# 516| r0_65(int) = Constant[0] :
|
||||
# 516| m0_66(int) = Store : r0_64, r0_65
|
||||
# 516| m0_67(Rect) = Chi : m0_63, m0_66
|
||||
# 516| r0_68(glval<Point>) = FieldAddress[bottomRight] : r0_57
|
||||
# 516| r0_69(glval<int>) = FieldAddress[x] : r0_68
|
||||
# 516| r0_70(glval<int>) = VariableAddress[x] :
|
||||
# 516| r0_71(int) = Load : r0_70, m0_3
|
||||
# 516| m0_72(int) = Store : r0_69, r0_71
|
||||
# 516| m0_73(Rect) = Chi : m0_67, m0_72
|
||||
# 516| r0_74(glval<int>) = FieldAddress[y] : r0_68
|
||||
# 516| r0_75(int) = Constant[0] :
|
||||
# 516| m0_76(int) = Store : r0_74, r0_75
|
||||
# 516| m0_77(Rect) = Chi : m0_73, m0_76
|
||||
# 517| v0_78(void) = NoOp :
|
||||
# 512| v0_79(void) = ReturnVoid :
|
||||
# 512| v0_80(void) = UnmodeledUse : mu*
|
||||
# 512| v0_81(void) = ExitFunction :
|
||||
# 513| m0_7(Rect) = Uninitialized : r0_6
|
||||
# 513| r0_8(glval<Point>) = FieldAddress[topLeft] : r0_6
|
||||
# 513| r0_9(Point) = Constant[0] :
|
||||
# 513| m0_10(Point) = Store : r0_8, r0_9
|
||||
# 513| m0_11(Rect) = Chi : m0_7, m0_10
|
||||
# 513| r0_12(glval<Point>) = FieldAddress[bottomRight] : r0_6
|
||||
# 513| r0_13(Point) = Constant[0] :
|
||||
# 513| m0_14(Point) = Store : r0_12, r0_13
|
||||
# 513| m0_15(Rect) = Chi : m0_11, m0_14
|
||||
# 514| r0_16(glval<Rect>) = VariableAddress[r2] :
|
||||
# 514| m0_17(Rect) = Uninitialized : r0_16
|
||||
# 514| r0_18(glval<Point>) = FieldAddress[topLeft] : r0_16
|
||||
# 514| r0_19(glval<int>) = FieldAddress[x] : r0_18
|
||||
# 514| r0_20(glval<int>) = VariableAddress[x] :
|
||||
# 514| r0_21(int) = Load : r0_20, m0_3
|
||||
# 514| m0_22(int) = Store : r0_19, r0_21
|
||||
# 514| m0_23(Rect) = Chi : m0_17, m0_22
|
||||
# 514| r0_24(glval<int>) = FieldAddress[y] : r0_18
|
||||
# 514| r0_25(glval<float>) = VariableAddress[f] :
|
||||
# 514| r0_26(float) = Load : r0_25, m0_5
|
||||
# 514| r0_27(int) = Convert : r0_26
|
||||
# 514| m0_28(int) = Store : r0_24, r0_27
|
||||
# 514| m0_29(Rect) = Chi : m0_23, m0_28
|
||||
# 514| r0_30(glval<Point>) = FieldAddress[bottomRight] : r0_16
|
||||
# 514| r0_31(Point) = Constant[0] :
|
||||
# 514| m0_32(Point) = Store : r0_30, r0_31
|
||||
# 514| m0_33(Rect) = Chi : m0_29, m0_32
|
||||
# 515| r0_34(glval<Rect>) = VariableAddress[r3] :
|
||||
# 515| m0_35(Rect) = Uninitialized : r0_34
|
||||
# 515| r0_36(glval<Point>) = FieldAddress[topLeft] : r0_34
|
||||
# 515| r0_37(glval<int>) = FieldAddress[x] : r0_36
|
||||
# 515| r0_38(glval<int>) = VariableAddress[x] :
|
||||
# 515| r0_39(int) = Load : r0_38, m0_3
|
||||
# 515| m0_40(int) = Store : r0_37, r0_39
|
||||
# 515| m0_41(Rect) = Chi : m0_35, m0_40
|
||||
# 515| r0_42(glval<int>) = FieldAddress[y] : r0_36
|
||||
# 515| r0_43(glval<float>) = VariableAddress[f] :
|
||||
# 515| r0_44(float) = Load : r0_43, m0_5
|
||||
# 515| r0_45(int) = Convert : r0_44
|
||||
# 515| m0_46(int) = Store : r0_42, r0_45
|
||||
# 515| m0_47(Rect) = Chi : m0_41, m0_46
|
||||
# 515| r0_48(glval<Point>) = FieldAddress[bottomRight] : r0_34
|
||||
# 515| r0_49(glval<int>) = FieldAddress[x] : r0_48
|
||||
# 515| r0_50(glval<int>) = VariableAddress[x] :
|
||||
# 515| r0_51(int) = Load : r0_50, m0_3
|
||||
# 515| m0_52(int) = Store : r0_49, r0_51
|
||||
# 515| m0_53(Rect) = Chi : m0_47, m0_52
|
||||
# 515| r0_54(glval<int>) = FieldAddress[y] : r0_48
|
||||
# 515| r0_55(glval<float>) = VariableAddress[f] :
|
||||
# 515| r0_56(float) = Load : r0_55, m0_5
|
||||
# 515| r0_57(int) = Convert : r0_56
|
||||
# 515| m0_58(int) = Store : r0_54, r0_57
|
||||
# 515| m0_59(Rect) = Chi : m0_53, m0_58
|
||||
# 516| r0_60(glval<Rect>) = VariableAddress[r4] :
|
||||
# 516| m0_61(Rect) = Uninitialized : r0_60
|
||||
# 516| r0_62(glval<Point>) = FieldAddress[topLeft] : r0_60
|
||||
# 516| r0_63(glval<int>) = FieldAddress[x] : r0_62
|
||||
# 516| r0_64(glval<int>) = VariableAddress[x] :
|
||||
# 516| r0_65(int) = Load : r0_64, m0_3
|
||||
# 516| m0_66(int) = Store : r0_63, r0_65
|
||||
# 516| m0_67(Rect) = Chi : m0_61, m0_66
|
||||
# 516| r0_68(glval<int>) = FieldAddress[y] : r0_62
|
||||
# 516| r0_69(int) = Constant[0] :
|
||||
# 516| m0_70(int) = Store : r0_68, r0_69
|
||||
# 516| m0_71(Rect) = Chi : m0_67, m0_70
|
||||
# 516| r0_72(glval<Point>) = FieldAddress[bottomRight] : r0_60
|
||||
# 516| r0_73(glval<int>) = FieldAddress[x] : r0_72
|
||||
# 516| r0_74(glval<int>) = VariableAddress[x] :
|
||||
# 516| r0_75(int) = Load : r0_74, m0_3
|
||||
# 516| m0_76(int) = Store : r0_73, r0_75
|
||||
# 516| m0_77(Rect) = Chi : m0_71, m0_76
|
||||
# 516| r0_78(glval<int>) = FieldAddress[y] : r0_72
|
||||
# 516| r0_79(int) = Constant[0] :
|
||||
# 516| m0_80(int) = Store : r0_78, r0_79
|
||||
# 516| m0_81(Rect) = Chi : m0_77, m0_80
|
||||
# 517| v0_82(void) = NoOp :
|
||||
# 512| v0_83(void) = ReturnVoid :
|
||||
# 512| v0_84(void) = UnmodeledUse : mu*
|
||||
# 512| v0_85(void) = ExitFunction :
|
||||
|
||||
# 519| ArrayInit(int, float) -> void
|
||||
# 519| Block 0
|
||||
@@ -2308,46 +2315,49 @@ ir.cpp:
|
||||
# 519| r0_4(glval<float>) = VariableAddress[f] :
|
||||
# 519| m0_5(float) = InitializeParameter[f] : r0_4
|
||||
# 520| r0_6(glval<int[3]>) = VariableAddress[a1] :
|
||||
# 520| r0_7(int) = Constant[0] :
|
||||
# 520| r0_8(glval<int>) = PointerAdd : r0_6, r0_7
|
||||
# 520| r0_9(unknown[12]) = Constant[0] :
|
||||
# 520| m0_10(unknown[12]) = Store : r0_8, r0_9
|
||||
# 520| m0_11(unknown) = Chi : mu0_1, m0_10
|
||||
# 521| r0_12(glval<int[3]>) = VariableAddress[a2] :
|
||||
# 521| r0_13(int) = Constant[0] :
|
||||
# 521| r0_14(glval<int>) = PointerAdd : r0_12, r0_13
|
||||
# 521| r0_15(glval<int>) = VariableAddress[x] :
|
||||
# 521| r0_16(int) = Load : r0_15, m0_3
|
||||
# 521| m0_17(int) = Store : r0_14, r0_16
|
||||
# 521| m0_18(unknown) = Chi : m0_11, m0_17
|
||||
# 521| r0_19(int) = Constant[1] :
|
||||
# 521| r0_20(glval<int>) = PointerAdd : r0_12, r0_19
|
||||
# 521| r0_21(glval<float>) = VariableAddress[f] :
|
||||
# 521| r0_22(float) = Load : r0_21, m0_5
|
||||
# 521| r0_23(int) = Convert : r0_22
|
||||
# 521| m0_24(int) = Store : r0_20, r0_23
|
||||
# 521| m0_25(unknown) = Chi : m0_18, m0_24
|
||||
# 521| r0_26(int) = Constant[2] :
|
||||
# 521| r0_27(glval<int>) = PointerAdd : r0_12, r0_26
|
||||
# 521| r0_28(int) = Constant[0] :
|
||||
# 521| m0_29(int) = Store : r0_27, r0_28
|
||||
# 521| m0_30(unknown) = Chi : m0_25, m0_29
|
||||
# 522| r0_31(glval<int[3]>) = VariableAddress[a3] :
|
||||
# 522| r0_32(int) = Constant[0] :
|
||||
# 522| r0_33(glval<int>) = PointerAdd : r0_31, r0_32
|
||||
# 522| r0_34(glval<int>) = VariableAddress[x] :
|
||||
# 522| r0_35(int) = Load : r0_34, m0_3
|
||||
# 522| m0_36(int) = Store : r0_33, r0_35
|
||||
# 522| m0_37(unknown) = Chi : m0_30, m0_36
|
||||
# 522| r0_38(int) = Constant[1] :
|
||||
# 522| r0_39(glval<int>) = PointerAdd : r0_31, r0_38
|
||||
# 522| r0_40(unknown[8]) = Constant[0] :
|
||||
# 522| m0_41(unknown[8]) = Store : r0_39, r0_40
|
||||
# 522| mu0_42(unknown) = Chi : m0_37, m0_41
|
||||
# 523| v0_43(void) = NoOp :
|
||||
# 519| v0_44(void) = ReturnVoid :
|
||||
# 519| v0_45(void) = UnmodeledUse : mu*
|
||||
# 519| v0_46(void) = ExitFunction :
|
||||
# 520| mu0_7(int[3]) = Uninitialized : r0_6
|
||||
# 520| r0_8(int) = Constant[0] :
|
||||
# 520| r0_9(glval<int>) = PointerAdd : r0_6, r0_8
|
||||
# 520| r0_10(unknown[12]) = Constant[0] :
|
||||
# 520| m0_11(unknown[12]) = Store : r0_9, r0_10
|
||||
# 520| m0_12(unknown) = Chi : mu0_1, m0_11
|
||||
# 521| r0_13(glval<int[3]>) = VariableAddress[a2] :
|
||||
# 521| mu0_14(int[3]) = Uninitialized : r0_13
|
||||
# 521| r0_15(int) = Constant[0] :
|
||||
# 521| r0_16(glval<int>) = PointerAdd : r0_13, r0_15
|
||||
# 521| r0_17(glval<int>) = VariableAddress[x] :
|
||||
# 521| r0_18(int) = Load : r0_17, m0_3
|
||||
# 521| m0_19(int) = Store : r0_16, r0_18
|
||||
# 521| m0_20(unknown) = Chi : m0_12, m0_19
|
||||
# 521| r0_21(int) = Constant[1] :
|
||||
# 521| r0_22(glval<int>) = PointerAdd : r0_13, r0_21
|
||||
# 521| r0_23(glval<float>) = VariableAddress[f] :
|
||||
# 521| r0_24(float) = Load : r0_23, m0_5
|
||||
# 521| r0_25(int) = Convert : r0_24
|
||||
# 521| m0_26(int) = Store : r0_22, r0_25
|
||||
# 521| m0_27(unknown) = Chi : m0_20, m0_26
|
||||
# 521| r0_28(int) = Constant[2] :
|
||||
# 521| r0_29(glval<int>) = PointerAdd : r0_13, r0_28
|
||||
# 521| r0_30(int) = Constant[0] :
|
||||
# 521| m0_31(int) = Store : r0_29, r0_30
|
||||
# 521| m0_32(unknown) = Chi : m0_27, m0_31
|
||||
# 522| r0_33(glval<int[3]>) = VariableAddress[a3] :
|
||||
# 522| mu0_34(int[3]) = Uninitialized : r0_33
|
||||
# 522| r0_35(int) = Constant[0] :
|
||||
# 522| r0_36(glval<int>) = PointerAdd : r0_33, r0_35
|
||||
# 522| r0_37(glval<int>) = VariableAddress[x] :
|
||||
# 522| r0_38(int) = Load : r0_37, m0_3
|
||||
# 522| m0_39(int) = Store : r0_36, r0_38
|
||||
# 522| m0_40(unknown) = Chi : m0_32, m0_39
|
||||
# 522| r0_41(int) = Constant[1] :
|
||||
# 522| r0_42(glval<int>) = PointerAdd : r0_33, r0_41
|
||||
# 522| r0_43(unknown[8]) = Constant[0] :
|
||||
# 522| m0_44(unknown[8]) = Store : r0_42, r0_43
|
||||
# 522| mu0_45(unknown) = Chi : m0_40, m0_44
|
||||
# 523| v0_46(void) = NoOp :
|
||||
# 519| v0_47(void) = ReturnVoid :
|
||||
# 519| v0_48(void) = UnmodeledUse : mu*
|
||||
# 519| v0_49(void) = ExitFunction :
|
||||
|
||||
# 530| UnionInit(int, float) -> void
|
||||
# 530| Block 0
|
||||
@@ -2358,15 +2368,16 @@ ir.cpp:
|
||||
# 530| r0_4(glval<float>) = VariableAddress[f] :
|
||||
# 530| m0_5(float) = InitializeParameter[f] : r0_4
|
||||
# 531| r0_6(glval<U>) = VariableAddress[u1] :
|
||||
# 531| r0_7(glval<double>) = FieldAddress[d] : r0_6
|
||||
# 531| r0_8(glval<float>) = VariableAddress[f] :
|
||||
# 531| r0_9(float) = Load : r0_8, m0_5
|
||||
# 531| r0_10(double) = Convert : r0_9
|
||||
# 531| m0_11(double) = Store : r0_7, r0_10
|
||||
# 533| v0_12(void) = NoOp :
|
||||
# 530| v0_13(void) = ReturnVoid :
|
||||
# 530| v0_14(void) = UnmodeledUse : mu*
|
||||
# 530| v0_15(void) = ExitFunction :
|
||||
# 531| m0_7(U) = Uninitialized : r0_6
|
||||
# 531| r0_8(glval<double>) = FieldAddress[d] : r0_6
|
||||
# 531| r0_9(glval<float>) = VariableAddress[f] :
|
||||
# 531| r0_10(float) = Load : r0_9, m0_5
|
||||
# 531| r0_11(double) = Convert : r0_10
|
||||
# 531| m0_12(double) = Store : r0_8, r0_11
|
||||
# 533| v0_13(void) = NoOp :
|
||||
# 530| v0_14(void) = ReturnVoid :
|
||||
# 530| v0_15(void) = UnmodeledUse : mu*
|
||||
# 530| v0_16(void) = ExitFunction :
|
||||
|
||||
# 535| EarlyReturn(int, int) -> void
|
||||
# 535| Block 0
|
||||
@@ -2528,48 +2539,52 @@ ir.cpp:
|
||||
# 575| r0_19(glval<char[2]>) = VariableAddress[b] :
|
||||
# 575| m0_20(char[2]) = Uninitialized : r0_19
|
||||
# 576| r0_21(glval<char[2]>) = VariableAddress[c] :
|
||||
# 576| r0_22(int) = Constant[0] :
|
||||
# 576| r0_23(glval<char>) = PointerAdd : r0_21, r0_22
|
||||
# 576| r0_24(unknown[2]) = Constant[0] :
|
||||
# 576| m0_25(unknown[2]) = Store : r0_23, r0_24
|
||||
# 576| m0_26(unknown) = Chi : m0_10, m0_25
|
||||
# 577| r0_27(glval<char[2]>) = VariableAddress[d] :
|
||||
# 577| r0_28(int) = Constant[0] :
|
||||
# 577| r0_29(glval<char>) = PointerAdd : r0_27, r0_28
|
||||
# 577| r0_30(char) = Constant[0] :
|
||||
# 577| m0_31(char) = Store : r0_29, r0_30
|
||||
# 577| m0_32(unknown) = Chi : m0_26, m0_31
|
||||
# 577| r0_33(int) = Constant[1] :
|
||||
# 577| r0_34(glval<char>) = PointerAdd : r0_27, r0_33
|
||||
# 577| r0_35(char) = Constant[0] :
|
||||
# 577| m0_36(char) = Store : r0_34, r0_35
|
||||
# 577| m0_37(unknown) = Chi : m0_32, m0_36
|
||||
# 578| r0_38(glval<char[2]>) = VariableAddress[e] :
|
||||
# 578| r0_39(int) = Constant[0] :
|
||||
# 578| r0_40(glval<char>) = PointerAdd : r0_38, r0_39
|
||||
# 578| r0_41(char) = Constant[0] :
|
||||
# 578| m0_42(char) = Store : r0_40, r0_41
|
||||
# 578| m0_43(unknown) = Chi : m0_37, m0_42
|
||||
# 578| r0_44(int) = Constant[1] :
|
||||
# 578| r0_45(glval<char>) = PointerAdd : r0_38, r0_44
|
||||
# 578| r0_46(char) = Constant[1] :
|
||||
# 578| m0_47(char) = Store : r0_45, r0_46
|
||||
# 578| m0_48(unknown) = Chi : m0_43, m0_47
|
||||
# 579| r0_49(glval<char[3]>) = VariableAddress[f] :
|
||||
# 579| r0_50(int) = Constant[0] :
|
||||
# 579| r0_51(glval<char>) = PointerAdd : r0_49, r0_50
|
||||
# 579| r0_52(char) = Constant[0] :
|
||||
# 579| m0_53(char) = Store : r0_51, r0_52
|
||||
# 579| m0_54(unknown) = Chi : m0_48, m0_53
|
||||
# 579| r0_55(int) = Constant[1] :
|
||||
# 579| r0_56(glval<char>) = PointerAdd : r0_49, r0_55
|
||||
# 579| r0_57(unknown[2]) = Constant[0] :
|
||||
# 579| m0_58(unknown[2]) = Store : r0_56, r0_57
|
||||
# 579| mu0_59(unknown) = Chi : m0_54, m0_58
|
||||
# 580| v0_60(void) = NoOp :
|
||||
# 571| v0_61(void) = ReturnVoid :
|
||||
# 571| v0_62(void) = UnmodeledUse : mu*
|
||||
# 571| v0_63(void) = ExitFunction :
|
||||
# 576| mu0_22(char[2]) = Uninitialized : r0_21
|
||||
# 576| r0_23(int) = Constant[0] :
|
||||
# 576| r0_24(glval<char>) = PointerAdd : r0_21, r0_23
|
||||
# 576| r0_25(unknown[2]) = Constant[0] :
|
||||
# 576| m0_26(unknown[2]) = Store : r0_24, r0_25
|
||||
# 576| m0_27(unknown) = Chi : m0_10, m0_26
|
||||
# 577| r0_28(glval<char[2]>) = VariableAddress[d] :
|
||||
# 577| mu0_29(char[2]) = Uninitialized : r0_28
|
||||
# 577| r0_30(int) = Constant[0] :
|
||||
# 577| r0_31(glval<char>) = PointerAdd : r0_28, r0_30
|
||||
# 577| r0_32(char) = Constant[0] :
|
||||
# 577| m0_33(char) = Store : r0_31, r0_32
|
||||
# 577| m0_34(unknown) = Chi : m0_27, m0_33
|
||||
# 577| r0_35(int) = Constant[1] :
|
||||
# 577| r0_36(glval<char>) = PointerAdd : r0_28, r0_35
|
||||
# 577| r0_37(char) = Constant[0] :
|
||||
# 577| m0_38(char) = Store : r0_36, r0_37
|
||||
# 577| m0_39(unknown) = Chi : m0_34, m0_38
|
||||
# 578| r0_40(glval<char[2]>) = VariableAddress[e] :
|
||||
# 578| mu0_41(char[2]) = Uninitialized : r0_40
|
||||
# 578| r0_42(int) = Constant[0] :
|
||||
# 578| r0_43(glval<char>) = PointerAdd : r0_40, r0_42
|
||||
# 578| r0_44(char) = Constant[0] :
|
||||
# 578| m0_45(char) = Store : r0_43, r0_44
|
||||
# 578| m0_46(unknown) = Chi : m0_39, m0_45
|
||||
# 578| r0_47(int) = Constant[1] :
|
||||
# 578| r0_48(glval<char>) = PointerAdd : r0_40, r0_47
|
||||
# 578| r0_49(char) = Constant[1] :
|
||||
# 578| m0_50(char) = Store : r0_48, r0_49
|
||||
# 578| m0_51(unknown) = Chi : m0_46, m0_50
|
||||
# 579| r0_52(glval<char[3]>) = VariableAddress[f] :
|
||||
# 579| mu0_53(char[3]) = Uninitialized : r0_52
|
||||
# 579| r0_54(int) = Constant[0] :
|
||||
# 579| r0_55(glval<char>) = PointerAdd : r0_52, r0_54
|
||||
# 579| r0_56(char) = Constant[0] :
|
||||
# 579| m0_57(char) = Store : r0_55, r0_56
|
||||
# 579| m0_58(unknown) = Chi : m0_51, m0_57
|
||||
# 579| r0_59(int) = Constant[1] :
|
||||
# 579| r0_60(glval<char>) = PointerAdd : r0_52, r0_59
|
||||
# 579| r0_61(unknown[2]) = Constant[0] :
|
||||
# 579| m0_62(unknown[2]) = Store : r0_60, r0_61
|
||||
# 579| mu0_63(unknown) = Chi : m0_58, m0_62
|
||||
# 580| v0_64(void) = NoOp :
|
||||
# 571| v0_65(void) = ReturnVoid :
|
||||
# 571| v0_66(void) = UnmodeledUse : mu*
|
||||
# 571| v0_67(void) = ExitFunction :
|
||||
|
||||
# 584| VarArgs() -> void
|
||||
# 584| Block 0
|
||||
@@ -3117,7 +3132,7 @@ ir.cpp:
|
||||
# 736| r10_5(char *) = Load : r10_4, m10_1
|
||||
# 736| v10_6(void) = Call : r10_3, this:r10_2, r10_5
|
||||
# 736| m10_7(unknown) = ^CallSideEffect : m9_0
|
||||
# 736| m10_8(unknown) = Chi : m10_7
|
||||
# 736| m10_8(unknown) = Chi : m9_0, m10_7
|
||||
# 736| v10_9(void) = ThrowValue : r10_2, mu0_1
|
||||
#-----| Exception -> Block 2
|
||||
|
||||
@@ -4160,11 +4175,12 @@ ir.cpp:
|
||||
# 961| v0_0(void) = EnterFunction :
|
||||
# 961| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 962| r0_2(glval<int[1000]>) = VariableAddress[a1] :
|
||||
# 962| r0_3(int) = Constant[0] :
|
||||
# 962| r0_4(glval<int>) = PointerAdd : r0_2, r0_3
|
||||
# 962| r0_5(unknown[8]) = Constant[0] :
|
||||
# 962| m0_6(unknown[8]) = Store : r0_4, r0_5
|
||||
# 962| m0_7(unknown) = Chi : mu0_1, m0_6
|
||||
# 962| mu0_3(int[1000]) = Uninitialized : r0_2
|
||||
# 962| r0_4(int) = Constant[0] :
|
||||
# 962| r0_5(glval<int>) = PointerAdd : r0_2, r0_4
|
||||
# 962| r0_6(unknown[8]) = Constant[0] :
|
||||
# 962| m0_7(unknown[8]) = Store : r0_5, r0_6
|
||||
# 962| m0_8(unknown) = Chi : mu0_1, m0_7
|
||||
#-----| Goto -> Block 2
|
||||
|
||||
# 962| Block 1
|
||||
@@ -4181,7 +4197,7 @@ ir.cpp:
|
||||
#-----| Goto -> Block 2
|
||||
|
||||
# 963| Block 2
|
||||
# 963| mu2_0(unknown) = Phi : from 0:m0_7, from 1:m1_9, from 3:m3_9
|
||||
# 963| mu2_0(unknown) = Phi : from 0:m0_8, from 1:m1_9, from 3:m3_9
|
||||
# 963| r2_1(glval<int>) = VariableAddress[#return] :
|
||||
# 963| r2_2(glval<int[1000]>) = VariableAddress[a1] :
|
||||
# 963| r2_3(int *) = Convert : r2_2
|
||||
@@ -4206,3 +4222,89 @@ ir.cpp:
|
||||
# 962| m3_8(unknown[3588]) = Store : r3_6, r3_7
|
||||
# 962| m3_9(unknown) = Chi : m3_4, m3_8
|
||||
#-----| Goto -> Block 2
|
||||
|
||||
# 984| ChiPhiNode(Point *, bool, bool) -> int
|
||||
# 984| Block 0
|
||||
# 984| v0_0(void) = EnterFunction :
|
||||
# 984| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 984| r0_2(glval<Point *>) = VariableAddress[p] :
|
||||
# 984| m0_3(Point *) = InitializeParameter[p] : r0_2
|
||||
# 984| r0_4(glval<bool>) = VariableAddress[which1] :
|
||||
# 984| m0_5(bool) = InitializeParameter[which1] : r0_4
|
||||
# 984| r0_6(glval<bool>) = VariableAddress[which2] :
|
||||
# 984| m0_7(bool) = InitializeParameter[which2] : r0_6
|
||||
# 985| r0_8(glval<bool>) = VariableAddress[which1] :
|
||||
# 985| r0_9(bool) = Load : r0_8, m0_5
|
||||
# 985| v0_10(void) = ConditionalBranch : r0_9
|
||||
#-----| False -> Block 2
|
||||
#-----| True -> Block 1
|
||||
|
||||
# 986| Block 1
|
||||
# 986| r1_0(glval<Point *>) = VariableAddress[p] :
|
||||
# 986| r1_1(Point *) = Load : r1_0, m0_3
|
||||
# 986| r1_2(glval<int>) = FieldAddress[x] : r1_1
|
||||
# 986| r1_3(int) = Load : r1_2, mu0_1
|
||||
# 986| r1_4(int) = Constant[1] :
|
||||
# 986| r1_5(int) = Add : r1_3, r1_4
|
||||
# 986| m1_6(int) = Store : r1_2, r1_5
|
||||
# 986| m1_7(unknown) = Chi : mu0_1, m1_6
|
||||
#-----| Goto -> Block 3
|
||||
|
||||
# 988| Block 2
|
||||
# 988| r2_0(glval<Point *>) = VariableAddress[p] :
|
||||
# 988| r2_1(Point *) = Load : r2_0, m0_3
|
||||
# 988| r2_2(glval<int>) = FieldAddress[y] : r2_1
|
||||
# 988| r2_3(int) = Load : r2_2, mu0_1
|
||||
# 988| r2_4(int) = Constant[1] :
|
||||
# 988| r2_5(int) = Add : r2_3, r2_4
|
||||
# 988| m2_6(int) = Store : r2_2, r2_5
|
||||
# 988| m2_7(unknown) = Chi : mu0_1, m2_6
|
||||
#-----| Goto -> Block 3
|
||||
|
||||
# 991| Block 3
|
||||
# 991| m3_0(unknown) = Phi : from 1:m1_7, from 2:m2_7
|
||||
# 991| r3_1(glval<bool>) = VariableAddress[which2] :
|
||||
# 991| r3_2(bool) = Load : r3_1, m0_7
|
||||
# 991| v3_3(void) = ConditionalBranch : r3_2
|
||||
#-----| False -> Block 5
|
||||
#-----| True -> Block 4
|
||||
|
||||
# 992| Block 4
|
||||
# 992| r4_0(glval<Point *>) = VariableAddress[p] :
|
||||
# 992| r4_1(Point *) = Load : r4_0, m0_3
|
||||
# 992| r4_2(glval<int>) = FieldAddress[x] : r4_1
|
||||
# 992| r4_3(int) = Load : r4_2, m3_0
|
||||
# 992| r4_4(int) = Constant[1] :
|
||||
# 992| r4_5(int) = Add : r4_3, r4_4
|
||||
# 992| m4_6(int) = Store : r4_2, r4_5
|
||||
# 992| m4_7(unknown) = Chi : m3_0, m4_6
|
||||
#-----| Goto -> Block 6
|
||||
|
||||
# 994| Block 5
|
||||
# 994| r5_0(glval<Point *>) = VariableAddress[p] :
|
||||
# 994| r5_1(Point *) = Load : r5_0, m0_3
|
||||
# 994| r5_2(glval<int>) = FieldAddress[y] : r5_1
|
||||
# 994| r5_3(int) = Load : r5_2, m3_0
|
||||
# 994| r5_4(int) = Constant[1] :
|
||||
# 994| r5_5(int) = Add : r5_3, r5_4
|
||||
# 994| m5_6(int) = Store : r5_2, r5_5
|
||||
# 994| m5_7(unknown) = Chi : m3_0, m5_6
|
||||
#-----| Goto -> Block 6
|
||||
|
||||
# 997| Block 6
|
||||
# 997| mu6_0(unknown) = Phi : from 4:m4_7, from 5:m5_7
|
||||
# 997| r6_1(glval<int>) = VariableAddress[#return] :
|
||||
# 997| r6_2(glval<Point *>) = VariableAddress[p] :
|
||||
# 997| r6_3(Point *) = Load : r6_2, m0_3
|
||||
# 997| r6_4(glval<int>) = FieldAddress[x] : r6_3
|
||||
# 997| r6_5(int) = Load : r6_4, mu6_0
|
||||
# 997| r6_6(glval<Point *>) = VariableAddress[p] :
|
||||
# 997| r6_7(Point *) = Load : r6_6, m0_3
|
||||
# 997| r6_8(glval<int>) = FieldAddress[y] : r6_7
|
||||
# 997| r6_9(int) = Load : r6_8, mu6_0
|
||||
# 997| r6_10(int) = Add : r6_5, r6_9
|
||||
# 997| m6_11(int) = Store : r6_1, r6_10
|
||||
# 984| r6_12(glval<int>) = VariableAddress[#return] :
|
||||
# 984| v6_13(void) = ReturnValue : r6_12, m6_11
|
||||
# 984| v6_14(void) = UnmodeledUse : mu*
|
||||
# 984| v6_15(void) = ExitFunction :
|
||||
|
||||
@@ -1,12 +1,4 @@
|
||||
missingOperand
|
||||
| ir.cpp:504:19:504:19 | Chi: x | ChiTotal |
|
||||
| ir.cpp:505:19:505:19 | Chi: x | ChiTotal |
|
||||
| ir.cpp:506:16:506:18 | Chi: {...} | ChiTotal |
|
||||
| ir.cpp:513:14:513:16 | Chi: {...} | ChiTotal |
|
||||
| ir.cpp:514:19:514:19 | Chi: x | ChiTotal |
|
||||
| ir.cpp:515:19:515:19 | Chi: x | ChiTotal |
|
||||
| ir.cpp:516:19:516:19 | Chi: x | ChiTotal |
|
||||
| ir.cpp:736:5:736:19 | Chi: call to String | ChiTotal |
|
||||
| ir.cpp:962:26:962:30 | Chi: 10002 | ChiTotal |
|
||||
| ir.cpp:962:41:962:45 | Chi: 10900 | ChiTotal |
|
||||
unexpectedOperand
|
||||
|
||||
@@ -1002,4 +1002,20 @@ void OperatorDeleteArray() {
|
||||
}
|
||||
#endif
|
||||
|
||||
int ChiPhiNode(Point *p, bool which1, bool which2) {
|
||||
if (which1) {
|
||||
p->x++;
|
||||
} else {
|
||||
p->y++;
|
||||
}
|
||||
|
||||
if (which2) {
|
||||
p->x++;
|
||||
} else {
|
||||
p->y++;
|
||||
}
|
||||
|
||||
return p->x + p->y;
|
||||
}
|
||||
|
||||
// semmle-extractor-options: -std=c++17
|
||||
|
||||
@@ -1,49 +1,3 @@
|
||||
bad_asts.cpp:
|
||||
# 14| Bad::CallBadMemberFunction() -> void
|
||||
# 14| Block 0
|
||||
# 14| v0_0(void) = EnterFunction :
|
||||
# 14| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 15| r0_2(glval<S>) = VariableAddress[s] :
|
||||
# 15| mu0_3(S) = Uninitialized : r0_2
|
||||
# 15| r0_4(glval<int>) = FieldAddress[x] : r0_2
|
||||
# 15| r0_5(int) = Constant[0] :
|
||||
# 15| mu0_6(int) = Store : r0_4, r0_5
|
||||
# 16| r0_7(glval<S>) = VariableAddress[s] :
|
||||
# 16| r0_8(glval<unknown>) = FunctionAddress[MemberFunction] :
|
||||
# 16| r0_9(int) = Constant[1] :
|
||||
# 16| r0_10(int) = Call : r0_8, this:r0_7, r0_9
|
||||
# 17| v0_11(void) = NoOp :
|
||||
# 14| v0_12(void) = ReturnVoid :
|
||||
# 14| v0_13(void) = UnmodeledUse : mu*
|
||||
# 14| v0_14(void) = ExitFunction :
|
||||
|
||||
# 22| Bad::Point::Point() -> void
|
||||
# 22| Block 0
|
||||
# 22| v0_0(void) = EnterFunction :
|
||||
# 22| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 22| r0_2(glval<Point>) = InitializeThis :
|
||||
# 23| v0_3(void) = NoOp :
|
||||
# 22| v0_4(void) = ReturnVoid :
|
||||
# 22| v0_5(void) = UnmodeledUse : mu*
|
||||
# 22| v0_6(void) = ExitFunction :
|
||||
|
||||
# 26| Bad::CallCopyConstructor(const Point &) -> void
|
||||
# 26| Block 0
|
||||
# 26| v0_0(void) = EnterFunction :
|
||||
# 26| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 26| r0_2(glval<Point &>) = VariableAddress[a] :
|
||||
# 26| mu0_3(Point &) = InitializeParameter[a] : r0_2
|
||||
# 27| r0_4(glval<Point>) = VariableAddress[b] :
|
||||
# 27| r0_5(glval<Point &>) = VariableAddress[a] :
|
||||
# 27| r0_6(Point &) = Load : r0_5, mu0_1
|
||||
# 27| r0_7(glval<Point>) = Convert : r0_6
|
||||
# 27| r0_8(Point) = Load : r0_7, mu0_1
|
||||
# 27| mu0_9(Point) = Store : r0_4, r0_8
|
||||
# 28| v0_10(void) = NoOp :
|
||||
# 26| v0_11(void) = ReturnVoid :
|
||||
# 26| v0_12(void) = UnmodeledUse : mu*
|
||||
# 26| v0_13(void) = ExitFunction :
|
||||
|
||||
ir.cpp:
|
||||
# 1| Constants() -> void
|
||||
# 1| Block 0
|
||||
@@ -4091,146 +4045,82 @@ ir.cpp:
|
||||
# 962| mu3_7(unknown[3588]) = Store : r3_5, r3_6
|
||||
#-----| Goto -> Block 2
|
||||
|
||||
# 966| IfStmtWithDeclaration(int, int) -> void
|
||||
# 966| Block 0
|
||||
# 966| v0_0(void) = EnterFunction :
|
||||
# 966| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 966| r0_2(glval<int>) = VariableAddress[x] :
|
||||
# 966| mu0_3(int) = InitializeParameter[x] : r0_2
|
||||
# 966| r0_4(glval<int>) = VariableAddress[y] :
|
||||
# 966| mu0_5(int) = InitializeParameter[y] : r0_4
|
||||
# 967| r0_6(glval<bool>) = VariableAddress[b] :
|
||||
# 967| r0_7(glval<int>) = VariableAddress[x] :
|
||||
# 967| r0_8(int) = Load : r0_7, mu0_1
|
||||
# 967| r0_9(glval<int>) = VariableAddress[y] :
|
||||
# 967| r0_10(int) = Load : r0_9, mu0_1
|
||||
# 967| r0_11(bool) = CompareLT : r0_8, r0_10
|
||||
# 967| mu0_12(bool) = Store : r0_6, r0_11
|
||||
# 967| r0_13(glval<bool>) = VariableAddress[b] :
|
||||
# 967| r0_14(bool) = Load : r0_13, mu0_1
|
||||
# 967| v0_15(void) = ConditionalBranch : r0_14
|
||||
# 984| ChiPhiNode(Point *, bool, bool) -> int
|
||||
# 984| Block 0
|
||||
# 984| v0_0(void) = EnterFunction :
|
||||
# 984| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 984| r0_2(glval<Point *>) = VariableAddress[p] :
|
||||
# 984| mu0_3(Point *) = InitializeParameter[p] : r0_2
|
||||
# 984| r0_4(glval<bool>) = VariableAddress[which1] :
|
||||
# 984| mu0_5(bool) = InitializeParameter[which1] : r0_4
|
||||
# 984| r0_6(glval<bool>) = VariableAddress[which2] :
|
||||
# 984| mu0_7(bool) = InitializeParameter[which2] : r0_6
|
||||
# 985| r0_8(glval<bool>) = VariableAddress[which1] :
|
||||
# 985| r0_9(bool) = Load : r0_8, mu0_1
|
||||
# 985| v0_10(void) = ConditionalBranch : r0_9
|
||||
#-----| False -> Block 2
|
||||
#-----| True -> Block 1
|
||||
|
||||
# 968| Block 1
|
||||
# 968| r1_0(int) = Constant[5] :
|
||||
# 968| r1_1(glval<int>) = VariableAddress[x] :
|
||||
# 968| mu1_2(int) = Store : r1_1, r1_0
|
||||
# 986| Block 1
|
||||
# 986| r1_0(glval<Point *>) = VariableAddress[p] :
|
||||
# 986| r1_1(Point *) = Load : r1_0, mu0_1
|
||||
# 986| r1_2(glval<int>) = FieldAddress[x] : r1_1
|
||||
# 986| r1_3(int) = Load : r1_2, mu0_1
|
||||
# 986| r1_4(int) = Constant[1] :
|
||||
# 986| r1_5(int) = Add : r1_3, r1_4
|
||||
# 986| mu1_6(int) = Store : r1_2, r1_5
|
||||
#-----| Goto -> Block 3
|
||||
|
||||
# 988| Block 2
|
||||
# 988| r2_0(glval<Point *>) = VariableAddress[p] :
|
||||
# 988| r2_1(Point *) = Load : r2_0, mu0_1
|
||||
# 988| r2_2(glval<int>) = FieldAddress[y] : r2_1
|
||||
# 988| r2_3(int) = Load : r2_2, mu0_1
|
||||
# 988| r2_4(int) = Constant[1] :
|
||||
# 988| r2_5(int) = Add : r2_3, r2_4
|
||||
# 988| mu2_6(int) = Store : r2_2, r2_5
|
||||
#-----| Goto -> Block 3
|
||||
|
||||
# 991| Block 3
|
||||
# 991| r3_0(glval<bool>) = VariableAddress[which2] :
|
||||
# 991| r3_1(bool) = Load : r3_0, mu0_1
|
||||
# 991| v3_2(void) = ConditionalBranch : r3_1
|
||||
#-----| False -> Block 5
|
||||
#-----| True -> Block 4
|
||||
|
||||
# 992| Block 4
|
||||
# 992| r4_0(glval<Point *>) = VariableAddress[p] :
|
||||
# 992| r4_1(Point *) = Load : r4_0, mu0_1
|
||||
# 992| r4_2(glval<int>) = FieldAddress[x] : r4_1
|
||||
# 992| r4_3(int) = Load : r4_2, mu0_1
|
||||
# 992| r4_4(int) = Constant[1] :
|
||||
# 992| r4_5(int) = Add : r4_3, r4_4
|
||||
# 992| mu4_6(int) = Store : r4_2, r4_5
|
||||
#-----| Goto -> Block 6
|
||||
|
||||
# 970| Block 2
|
||||
# 970| r2_0(glval<int>) = VariableAddress[z] :
|
||||
# 970| r2_1(glval<int>) = VariableAddress[x] :
|
||||
# 970| r2_2(int) = Load : r2_1, mu0_1
|
||||
# 970| r2_3(glval<int>) = VariableAddress[y] :
|
||||
# 970| r2_4(int) = Load : r2_3, mu0_1
|
||||
# 970| r2_5(int) = Add : r2_2, r2_4
|
||||
# 970| mu2_6(int) = Store : r2_0, r2_5
|
||||
# 970| r2_7(glval<int>) = VariableAddress[z] :
|
||||
# 970| r2_8(int) = Load : r2_7, mu0_1
|
||||
# 970| r2_9(int) = Constant[0] :
|
||||
# 970| r2_10(bool) = CompareNE : r2_8, r2_9
|
||||
# 970| v2_11(void) = ConditionalBranch : r2_10
|
||||
#-----| False -> Block 4
|
||||
#-----| True -> Block 3
|
||||
|
||||
# 971| Block 3
|
||||
# 971| r3_0(int) = Constant[7] :
|
||||
# 971| r3_1(glval<int>) = VariableAddress[y] :
|
||||
# 971| mu3_2(int) = Store : r3_1, r3_0
|
||||
# 994| Block 5
|
||||
# 994| r5_0(glval<Point *>) = VariableAddress[p] :
|
||||
# 994| r5_1(Point *) = Load : r5_0, mu0_1
|
||||
# 994| r5_2(glval<int>) = FieldAddress[y] : r5_1
|
||||
# 994| r5_3(int) = Load : r5_2, mu0_1
|
||||
# 994| r5_4(int) = Constant[1] :
|
||||
# 994| r5_5(int) = Add : r5_3, r5_4
|
||||
# 994| mu5_6(int) = Store : r5_2, r5_5
|
||||
#-----| Goto -> Block 6
|
||||
|
||||
# 973| Block 4
|
||||
# 973| r4_0(glval<int *>) = VariableAddress[p] :
|
||||
# 973| r4_1(glval<int>) = VariableAddress[x] :
|
||||
# 973| mu4_2(int *) = Store : r4_0, r4_1
|
||||
# 973| r4_3(glval<int *>) = VariableAddress[p] :
|
||||
# 973| r4_4(int *) = Load : r4_3, mu0_1
|
||||
# 973| r4_5(int *) = Constant[0] :
|
||||
# 973| r4_6(bool) = CompareNE : r4_4, r4_5
|
||||
# 973| v4_7(void) = ConditionalBranch : r4_6
|
||||
#-----| False -> Block 6
|
||||
#-----| True -> Block 5
|
||||
|
||||
# 974| Block 5
|
||||
# 974| r5_0(int) = Constant[2] :
|
||||
# 974| r5_1(glval<int *>) = VariableAddress[p] :
|
||||
# 974| r5_2(int *) = Load : r5_1, mu0_1
|
||||
# 974| mu5_3(int) = Store : r5_2, r5_0
|
||||
#-----| Goto -> Block 6
|
||||
|
||||
# 976| Block 6
|
||||
# 976| v6_0(void) = NoOp :
|
||||
# 966| v6_1(void) = ReturnVoid :
|
||||
# 966| v6_2(void) = UnmodeledUse : mu*
|
||||
# 966| v6_3(void) = ExitFunction :
|
||||
|
||||
# 978| WhileStmtWithDeclaration(int, int) -> void
|
||||
# 978| Block 0
|
||||
# 978| v0_0(void) = EnterFunction :
|
||||
# 978| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 978| r0_2(glval<int>) = VariableAddress[x] :
|
||||
# 978| mu0_3(int) = InitializeParameter[x] : r0_2
|
||||
# 978| r0_4(glval<int>) = VariableAddress[y] :
|
||||
# 978| mu0_5(int) = InitializeParameter[y] : r0_4
|
||||
#-----| Goto -> Block 7
|
||||
|
||||
# 979| Block 1
|
||||
# 979| v1_0(void) = NoOp :
|
||||
#-----| Goto -> Block 7
|
||||
|
||||
# 981| Block 2
|
||||
# 981| r2_0(glval<int>) = VariableAddress[z] :
|
||||
# 981| r2_1(glval<int>) = VariableAddress[x] :
|
||||
# 981| r2_2(int) = Load : r2_1, mu0_1
|
||||
# 981| r2_3(glval<int>) = VariableAddress[y] :
|
||||
# 981| r2_4(int) = Load : r2_3, mu0_1
|
||||
# 981| r2_5(int) = Add : r2_2, r2_4
|
||||
# 981| mu2_6(int) = Store : r2_0, r2_5
|
||||
# 981| r2_7(glval<int>) = VariableAddress[z] :
|
||||
# 981| r2_8(int) = Load : r2_7, mu0_1
|
||||
# 981| r2_9(int) = Constant[0] :
|
||||
# 981| r2_10(bool) = CompareNE : r2_8, r2_9
|
||||
# 981| v2_11(void) = ConditionalBranch : r2_10
|
||||
#-----| False -> Block 4
|
||||
#-----| True -> Block 3
|
||||
|
||||
# 981| Block 3
|
||||
# 981| v3_0(void) = NoOp :
|
||||
#-----| Goto -> Block 2
|
||||
|
||||
# 983| Block 4
|
||||
# 983| r4_0(glval<int *>) = VariableAddress[p] :
|
||||
# 983| r4_1(glval<int>) = VariableAddress[x] :
|
||||
# 983| mu4_2(int *) = Store : r4_0, r4_1
|
||||
# 983| r4_3(glval<int *>) = VariableAddress[p] :
|
||||
# 983| r4_4(int *) = Load : r4_3, mu0_1
|
||||
# 983| r4_5(int *) = Constant[0] :
|
||||
# 983| r4_6(bool) = CompareNE : r4_4, r4_5
|
||||
# 983| v4_7(void) = ConditionalBranch : r4_6
|
||||
#-----| False -> Block 6
|
||||
#-----| True -> Block 5
|
||||
|
||||
# 983| Block 5
|
||||
# 983| v5_0(void) = NoOp :
|
||||
#-----| Goto -> Block 4
|
||||
|
||||
# 985| Block 6
|
||||
# 985| v6_0(void) = NoOp :
|
||||
# 978| v6_1(void) = ReturnVoid :
|
||||
# 978| v6_2(void) = UnmodeledUse : mu*
|
||||
# 978| v6_3(void) = ExitFunction :
|
||||
|
||||
# 979| Block 7
|
||||
# 979| r7_0(glval<bool>) = VariableAddress[b] :
|
||||
# 979| r7_1(glval<int>) = VariableAddress[x] :
|
||||
# 979| r7_2(int) = Load : r7_1, mu0_1
|
||||
# 979| r7_3(glval<int>) = VariableAddress[y] :
|
||||
# 979| r7_4(int) = Load : r7_3, mu0_1
|
||||
# 979| r7_5(bool) = CompareLT : r7_2, r7_4
|
||||
# 979| mu7_6(bool) = Store : r7_0, r7_5
|
||||
# 979| r7_7(glval<bool>) = VariableAddress[b] :
|
||||
# 979| r7_8(bool) = Load : r7_7, mu0_1
|
||||
# 979| v7_9(void) = ConditionalBranch : r7_8
|
||||
#-----| False -> Block 2
|
||||
#-----| True -> Block 1
|
||||
# 997| Block 6
|
||||
# 997| r6_0(glval<int>) = VariableAddress[#return] :
|
||||
# 997| r6_1(glval<Point *>) = VariableAddress[p] :
|
||||
# 997| r6_2(Point *) = Load : r6_1, mu0_1
|
||||
# 997| r6_3(glval<int>) = FieldAddress[x] : r6_2
|
||||
# 997| r6_4(int) = Load : r6_3, mu0_1
|
||||
# 997| r6_5(glval<Point *>) = VariableAddress[p] :
|
||||
# 997| r6_6(Point *) = Load : r6_5, mu0_1
|
||||
# 997| r6_7(glval<int>) = FieldAddress[y] : r6_6
|
||||
# 997| r6_8(int) = Load : r6_7, mu0_1
|
||||
# 997| r6_9(int) = Add : r6_4, r6_8
|
||||
# 997| mu6_10(int) = Store : r6_0, r6_9
|
||||
# 984| r6_11(glval<int>) = VariableAddress[#return] :
|
||||
# 984| v6_12(void) = ReturnValue : r6_11, mu0_1
|
||||
# 984| v6_13(void) = UnmodeledUse : mu*
|
||||
# 984| v6_14(void) = ExitFunction :
|
||||
|
||||
@@ -15,6 +15,7 @@
|
||||
| IR: CallNestedTemplateFunc | 1 |
|
||||
| IR: CallViaFuncPtr | 1 |
|
||||
| IR: CastToVoid | 1 |
|
||||
| IR: ChiPhiNode | 7 |
|
||||
| IR: Comma | 1 |
|
||||
| IR: CompoundAssignment | 1 |
|
||||
| IR: ConditionValues | 13 |
|
||||
|
||||
@@ -1,49 +1,3 @@
|
||||
bad_asts.cpp:
|
||||
# 14| Bad::CallBadMemberFunction() -> void
|
||||
# 14| Block 0
|
||||
# 14| v0_0(void) = EnterFunction :
|
||||
# 14| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 15| r0_2(glval<S>) = VariableAddress[s] :
|
||||
# 15| mu0_3(S) = Uninitialized : r0_2
|
||||
# 15| r0_4(glval<int>) = FieldAddress[x] : r0_2
|
||||
# 15| r0_5(int) = Constant[0] :
|
||||
# 15| mu0_6(int) = Store : r0_4, r0_5
|
||||
# 16| r0_7(glval<S>) = VariableAddress[s] :
|
||||
# 16| r0_8(glval<unknown>) = FunctionAddress[MemberFunction] :
|
||||
# 16| r0_9(int) = Constant[1] :
|
||||
# 16| r0_10(int) = Call : r0_8, this:r0_7, r0_9
|
||||
# 17| v0_11(void) = NoOp :
|
||||
# 14| v0_12(void) = ReturnVoid :
|
||||
# 14| v0_13(void) = UnmodeledUse : mu*
|
||||
# 14| v0_14(void) = ExitFunction :
|
||||
|
||||
# 22| Bad::Point::Point() -> void
|
||||
# 22| Block 0
|
||||
# 22| v0_0(void) = EnterFunction :
|
||||
# 22| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 22| r0_2(glval<Point>) = InitializeThis :
|
||||
# 23| v0_3(void) = NoOp :
|
||||
# 22| v0_4(void) = ReturnVoid :
|
||||
# 22| v0_5(void) = UnmodeledUse : mu*
|
||||
# 22| v0_6(void) = ExitFunction :
|
||||
|
||||
# 26| Bad::CallCopyConstructor(const Point &) -> void
|
||||
# 26| Block 0
|
||||
# 26| v0_0(void) = EnterFunction :
|
||||
# 26| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 26| r0_2(glval<Point &>) = VariableAddress[a] :
|
||||
# 26| m0_3(Point &) = InitializeParameter[a] : r0_2
|
||||
# 27| r0_4(glval<Point>) = VariableAddress[b] :
|
||||
# 27| r0_5(glval<Point &>) = VariableAddress[a] :
|
||||
# 27| r0_6(Point &) = Load : r0_5, m0_3
|
||||
# 27| r0_7(glval<Point>) = Convert : r0_6
|
||||
# 27| r0_8(Point) = Load : r0_7, mu0_1
|
||||
# 27| m0_9(Point) = Store : r0_4, r0_8
|
||||
# 28| v0_10(void) = NoOp :
|
||||
# 26| v0_11(void) = ReturnVoid :
|
||||
# 26| v0_12(void) = UnmodeledUse : mu*
|
||||
# 26| v0_13(void) = ExitFunction :
|
||||
|
||||
ir.cpp:
|
||||
# 1| Constants() -> void
|
||||
# 1| Block 0
|
||||
@@ -4112,146 +4066,82 @@ ir.cpp:
|
||||
# 962| mu3_7(unknown[3588]) = Store : r3_5, r3_6
|
||||
#-----| Goto -> Block 2
|
||||
|
||||
# 966| IfStmtWithDeclaration(int, int) -> void
|
||||
# 966| Block 0
|
||||
# 966| v0_0(void) = EnterFunction :
|
||||
# 966| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 966| r0_2(glval<int>) = VariableAddress[x] :
|
||||
# 966| mu0_3(int) = InitializeParameter[x] : r0_2
|
||||
# 966| r0_4(glval<int>) = VariableAddress[y] :
|
||||
# 966| m0_5(int) = InitializeParameter[y] : r0_4
|
||||
# 967| r0_6(glval<bool>) = VariableAddress[b] :
|
||||
# 967| r0_7(glval<int>) = VariableAddress[x] :
|
||||
# 967| r0_8(int) = Load : r0_7, mu0_1
|
||||
# 967| r0_9(glval<int>) = VariableAddress[y] :
|
||||
# 967| r0_10(int) = Load : r0_9, m0_5
|
||||
# 967| r0_11(bool) = CompareLT : r0_8, r0_10
|
||||
# 967| m0_12(bool) = Store : r0_6, r0_11
|
||||
# 967| r0_13(glval<bool>) = VariableAddress[b] :
|
||||
# 967| r0_14(bool) = Load : r0_13, m0_12
|
||||
# 967| v0_15(void) = ConditionalBranch : r0_14
|
||||
# 984| ChiPhiNode(Point *, bool, bool) -> int
|
||||
# 984| Block 0
|
||||
# 984| v0_0(void) = EnterFunction :
|
||||
# 984| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 984| r0_2(glval<Point *>) = VariableAddress[p] :
|
||||
# 984| m0_3(Point *) = InitializeParameter[p] : r0_2
|
||||
# 984| r0_4(glval<bool>) = VariableAddress[which1] :
|
||||
# 984| m0_5(bool) = InitializeParameter[which1] : r0_4
|
||||
# 984| r0_6(glval<bool>) = VariableAddress[which2] :
|
||||
# 984| m0_7(bool) = InitializeParameter[which2] : r0_6
|
||||
# 985| r0_8(glval<bool>) = VariableAddress[which1] :
|
||||
# 985| r0_9(bool) = Load : r0_8, m0_5
|
||||
# 985| v0_10(void) = ConditionalBranch : r0_9
|
||||
#-----| False -> Block 2
|
||||
#-----| True -> Block 1
|
||||
|
||||
# 968| Block 1
|
||||
# 968| r1_0(int) = Constant[5] :
|
||||
# 968| r1_1(glval<int>) = VariableAddress[x] :
|
||||
# 968| mu1_2(int) = Store : r1_1, r1_0
|
||||
# 986| Block 1
|
||||
# 986| r1_0(glval<Point *>) = VariableAddress[p] :
|
||||
# 986| r1_1(Point *) = Load : r1_0, m0_3
|
||||
# 986| r1_2(glval<int>) = FieldAddress[x] : r1_1
|
||||
# 986| r1_3(int) = Load : r1_2, mu0_1
|
||||
# 986| r1_4(int) = Constant[1] :
|
||||
# 986| r1_5(int) = Add : r1_3, r1_4
|
||||
# 986| mu1_6(int) = Store : r1_2, r1_5
|
||||
#-----| Goto -> Block 3
|
||||
|
||||
# 988| Block 2
|
||||
# 988| r2_0(glval<Point *>) = VariableAddress[p] :
|
||||
# 988| r2_1(Point *) = Load : r2_0, m0_3
|
||||
# 988| r2_2(glval<int>) = FieldAddress[y] : r2_1
|
||||
# 988| r2_3(int) = Load : r2_2, mu0_1
|
||||
# 988| r2_4(int) = Constant[1] :
|
||||
# 988| r2_5(int) = Add : r2_3, r2_4
|
||||
# 988| mu2_6(int) = Store : r2_2, r2_5
|
||||
#-----| Goto -> Block 3
|
||||
|
||||
# 991| Block 3
|
||||
# 991| r3_0(glval<bool>) = VariableAddress[which2] :
|
||||
# 991| r3_1(bool) = Load : r3_0, m0_7
|
||||
# 991| v3_2(void) = ConditionalBranch : r3_1
|
||||
#-----| False -> Block 5
|
||||
#-----| True -> Block 4
|
||||
|
||||
# 992| Block 4
|
||||
# 992| r4_0(glval<Point *>) = VariableAddress[p] :
|
||||
# 992| r4_1(Point *) = Load : r4_0, m0_3
|
||||
# 992| r4_2(glval<int>) = FieldAddress[x] : r4_1
|
||||
# 992| r4_3(int) = Load : r4_2, mu0_1
|
||||
# 992| r4_4(int) = Constant[1] :
|
||||
# 992| r4_5(int) = Add : r4_3, r4_4
|
||||
# 992| mu4_6(int) = Store : r4_2, r4_5
|
||||
#-----| Goto -> Block 6
|
||||
|
||||
# 970| Block 2
|
||||
# 970| r2_0(glval<int>) = VariableAddress[z] :
|
||||
# 970| r2_1(glval<int>) = VariableAddress[x] :
|
||||
# 970| r2_2(int) = Load : r2_1, mu0_1
|
||||
# 970| r2_3(glval<int>) = VariableAddress[y] :
|
||||
# 970| r2_4(int) = Load : r2_3, m0_5
|
||||
# 970| r2_5(int) = Add : r2_2, r2_4
|
||||
# 970| m2_6(int) = Store : r2_0, r2_5
|
||||
# 970| r2_7(glval<int>) = VariableAddress[z] :
|
||||
# 970| r2_8(int) = Load : r2_7, m2_6
|
||||
# 970| r2_9(int) = Constant[0] :
|
||||
# 970| r2_10(bool) = CompareNE : r2_8, r2_9
|
||||
# 970| v2_11(void) = ConditionalBranch : r2_10
|
||||
#-----| False -> Block 4
|
||||
#-----| True -> Block 3
|
||||
|
||||
# 971| Block 3
|
||||
# 971| r3_0(int) = Constant[7] :
|
||||
# 971| r3_1(glval<int>) = VariableAddress[y] :
|
||||
# 971| m3_2(int) = Store : r3_1, r3_0
|
||||
# 994| Block 5
|
||||
# 994| r5_0(glval<Point *>) = VariableAddress[p] :
|
||||
# 994| r5_1(Point *) = Load : r5_0, m0_3
|
||||
# 994| r5_2(glval<int>) = FieldAddress[y] : r5_1
|
||||
# 994| r5_3(int) = Load : r5_2, mu0_1
|
||||
# 994| r5_4(int) = Constant[1] :
|
||||
# 994| r5_5(int) = Add : r5_3, r5_4
|
||||
# 994| mu5_6(int) = Store : r5_2, r5_5
|
||||
#-----| Goto -> Block 6
|
||||
|
||||
# 973| Block 4
|
||||
# 973| r4_0(glval<int *>) = VariableAddress[p] :
|
||||
# 973| r4_1(glval<int>) = VariableAddress[x] :
|
||||
# 973| m4_2(int *) = Store : r4_0, r4_1
|
||||
# 973| r4_3(glval<int *>) = VariableAddress[p] :
|
||||
# 973| r4_4(int *) = Load : r4_3, m4_2
|
||||
# 973| r4_5(int *) = Constant[0] :
|
||||
# 973| r4_6(bool) = CompareNE : r4_4, r4_5
|
||||
# 973| v4_7(void) = ConditionalBranch : r4_6
|
||||
#-----| False -> Block 6
|
||||
#-----| True -> Block 5
|
||||
|
||||
# 974| Block 5
|
||||
# 974| r5_0(int) = Constant[2] :
|
||||
# 974| r5_1(glval<int *>) = VariableAddress[p] :
|
||||
# 974| r5_2(int *) = Load : r5_1, m4_2
|
||||
# 974| mu5_3(int) = Store : r5_2, r5_0
|
||||
#-----| Goto -> Block 6
|
||||
|
||||
# 976| Block 6
|
||||
# 976| v6_0(void) = NoOp :
|
||||
# 966| v6_1(void) = ReturnVoid :
|
||||
# 966| v6_2(void) = UnmodeledUse : mu*
|
||||
# 966| v6_3(void) = ExitFunction :
|
||||
|
||||
# 978| WhileStmtWithDeclaration(int, int) -> void
|
||||
# 978| Block 0
|
||||
# 978| v0_0(void) = EnterFunction :
|
||||
# 978| mu0_1(unknown) = UnmodeledDefinition :
|
||||
# 978| r0_2(glval<int>) = VariableAddress[x] :
|
||||
# 978| mu0_3(int) = InitializeParameter[x] : r0_2
|
||||
# 978| r0_4(glval<int>) = VariableAddress[y] :
|
||||
# 978| m0_5(int) = InitializeParameter[y] : r0_4
|
||||
#-----| Goto -> Block 7
|
||||
|
||||
# 979| Block 1
|
||||
# 979| v1_0(void) = NoOp :
|
||||
#-----| Goto -> Block 7
|
||||
|
||||
# 981| Block 2
|
||||
# 981| r2_0(glval<int>) = VariableAddress[z] :
|
||||
# 981| r2_1(glval<int>) = VariableAddress[x] :
|
||||
# 981| r2_2(int) = Load : r2_1, mu0_1
|
||||
# 981| r2_3(glval<int>) = VariableAddress[y] :
|
||||
# 981| r2_4(int) = Load : r2_3, m0_5
|
||||
# 981| r2_5(int) = Add : r2_2, r2_4
|
||||
# 981| m2_6(int) = Store : r2_0, r2_5
|
||||
# 981| r2_7(glval<int>) = VariableAddress[z] :
|
||||
# 981| r2_8(int) = Load : r2_7, m2_6
|
||||
# 981| r2_9(int) = Constant[0] :
|
||||
# 981| r2_10(bool) = CompareNE : r2_8, r2_9
|
||||
# 981| v2_11(void) = ConditionalBranch : r2_10
|
||||
#-----| False -> Block 4
|
||||
#-----| True -> Block 3
|
||||
|
||||
# 981| Block 3
|
||||
# 981| v3_0(void) = NoOp :
|
||||
#-----| Goto -> Block 2
|
||||
|
||||
# 983| Block 4
|
||||
# 983| r4_0(glval<int *>) = VariableAddress[p] :
|
||||
# 983| r4_1(glval<int>) = VariableAddress[x] :
|
||||
# 983| m4_2(int *) = Store : r4_0, r4_1
|
||||
# 983| r4_3(glval<int *>) = VariableAddress[p] :
|
||||
# 983| r4_4(int *) = Load : r4_3, m4_2
|
||||
# 983| r4_5(int *) = Constant[0] :
|
||||
# 983| r4_6(bool) = CompareNE : r4_4, r4_5
|
||||
# 983| v4_7(void) = ConditionalBranch : r4_6
|
||||
#-----| False -> Block 6
|
||||
#-----| True -> Block 5
|
||||
|
||||
# 983| Block 5
|
||||
# 983| v5_0(void) = NoOp :
|
||||
#-----| Goto -> Block 4
|
||||
|
||||
# 985| Block 6
|
||||
# 985| v6_0(void) = NoOp :
|
||||
# 978| v6_1(void) = ReturnVoid :
|
||||
# 978| v6_2(void) = UnmodeledUse : mu*
|
||||
# 978| v6_3(void) = ExitFunction :
|
||||
|
||||
# 979| Block 7
|
||||
# 979| r7_0(glval<bool>) = VariableAddress[b] :
|
||||
# 979| r7_1(glval<int>) = VariableAddress[x] :
|
||||
# 979| r7_2(int) = Load : r7_1, mu0_1
|
||||
# 979| r7_3(glval<int>) = VariableAddress[y] :
|
||||
# 979| r7_4(int) = Load : r7_3, m0_5
|
||||
# 979| r7_5(bool) = CompareLT : r7_2, r7_4
|
||||
# 979| m7_6(bool) = Store : r7_0, r7_5
|
||||
# 979| r7_7(glval<bool>) = VariableAddress[b] :
|
||||
# 979| r7_8(bool) = Load : r7_7, m7_6
|
||||
# 979| v7_9(void) = ConditionalBranch : r7_8
|
||||
#-----| False -> Block 2
|
||||
#-----| True -> Block 1
|
||||
# 997| Block 6
|
||||
# 997| r6_0(glval<int>) = VariableAddress[#return] :
|
||||
# 997| r6_1(glval<Point *>) = VariableAddress[p] :
|
||||
# 997| r6_2(Point *) = Load : r6_1, m0_3
|
||||
# 997| r6_3(glval<int>) = FieldAddress[x] : r6_2
|
||||
# 997| r6_4(int) = Load : r6_3, mu0_1
|
||||
# 997| r6_5(glval<Point *>) = VariableAddress[p] :
|
||||
# 997| r6_6(Point *) = Load : r6_5, m0_3
|
||||
# 997| r6_7(glval<int>) = FieldAddress[y] : r6_6
|
||||
# 997| r6_8(int) = Load : r6_7, mu0_1
|
||||
# 997| r6_9(int) = Add : r6_4, r6_8
|
||||
# 997| m6_10(int) = Store : r6_0, r6_9
|
||||
# 984| r6_11(glval<int>) = VariableAddress[#return] :
|
||||
# 984| v6_12(void) = ReturnValue : r6_11, m6_10
|
||||
# 984| v6_13(void) = UnmodeledUse : mu*
|
||||
# 984| v6_14(void) = ExitFunction :
|
||||
|
||||
Reference in New Issue
Block a user