Skip to content

Instantly share code, notes, and snippets.

@MrSmith33

MrSmith33/debugging_ra.d

Created October 10, 2019 08:34
Show Gist options
  • Save MrSmith33/4bc52e8081b628dc71ce8d9f80c9f540 to your computer and use it in GitHub Desktop.
Save MrSmith33/4bc52e8081b628dc71ce8d9f80c9f540 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
debugging_ra.d
intervals formatInt
p 0 rax [rax]: [40; 41) [86; 88) [108; 112)
p 1 rcx [rcx]: [1; 2) [30; 41)
p 2 rdx [rdx]: [1; 4) [32; 41) [84; 90) [106; 110)
p 4 rsp [rsp]: [36; 44)
p 8 r8 [r8]: [1; 6) [34; 41)
p 9 r9 [r9]: [1; 8) [36; 41)
p 10 r10 [r10]: [40; 41)
p 11 r11 [r11]: [40; 41)
v 16 v0 [no reg]: minSize [24; 48) (28 instr) (48 phi)
v 17 v1 [no reg]: i [62; 66) (64 instr) (66 phi)
v 18 v2 [no reg]: i [72; 74) (74 phi)
v 19 v3 [no reg]: numDigits [76; 96) [116; 118) (96 instr) (118 phi)
v 20 v4 [no reg]: i [76; 104) (78 instr) (82 instr) (104 instr)
v 21 v5 [no reg]: numDigits [120; 126) [136; 142) (122 instr) (126 instr) (138 phi) (142 instr)
v 22 v6 [no reg]: numDigits [152; 166) (154 phi) (166 phi)
v 23 v7 [no reg]: numDigits [168; 182) (174 instr) (182 instr)
v 24 v8 [no reg]: i [2; 14) [50; 58) (2 instr) (14 instr) (52 instr) (54 phi) (58 instr)
v 25 v9 [no reg]: output [4; 172) (4 instr) (26 instr) (44 instr) (100 instr) (130 instr) (146 instr) (158 instr) (172 instr)
v 26 v10 [no reg]: minSize [6; 18) [50; 134) (6 instr) (18 instr) (18 phi) (122 instr)
v 27 v11 [no reg]: result [8; 180) (8 instr) (170 instr) (180 instr)
v 28 v12 [no reg]: neg [52; 138) (52 instr) (54 instr) (138 instr)
v 29 v13 [no reg]: (*output).ptr [26; 30) (26 instr) (30 instr)
v 30 v14 [no reg]: 21 - minSize [28; 32) (28 instr) (32 instr)
v 31 v15 [no reg]: (*output)[20] [44; 46) (44 instr) (46 instr)
v 32 v16 [no reg]: -i [58; 60) (58 instr) (60 phi)
v 33 v17 [no reg]: overflow [64; 154) (64 instr) (66 instr) (154 instr)
v 34 v18 [no reg]: 10 [86; 88) (86 instr) (88 instr)
v 35 v19 [no reg]: i % 10 [90; 92) (90 instr) (92 instr)
v 36 v20 [no reg]: '0' + i % 10 [92; 94) (92 instr) (94 instr)
v 37 v21 [no reg]: cast(u8)('0' + i % 10) [94; 102) (94 instr) (102 instr)
v 38 v22 [no reg]: numDigits [96; 114) (96 instr) (98 instr) (114 phi)
v 39 v23 [no reg]: 21 - ++numDigits [98; 100) (98 instr) (100 instr)
v 40 v24 [no reg]: (*output)[21 - ++numDigits] [100; 102) (100 instr) (102 instr)
v 41 v25 [no reg]: 10 [108; 110) (108 instr) (110 instr)
v 42 v26 [no reg]: i [112; 114) (112 instr) (114 phi)
v 43 v27 [no reg]: numDigits [126; 134) (126 instr) (128 instr) (134 phi)
v 44 v28 [no reg]: 21 - ++numDigits [128; 130) (128 instr) (130 instr)
v 45 v29 [no reg]: (*output)[21 - ++numDigits] [130; 132) (130 instr) (132 instr)
v 46 v30 [no reg]: numDigits [142; 150) (142 instr) (144 instr) (150 phi)
v 47 v31 [no reg]: 21 - ++numDigits [144; 146) (144 instr) (146 instr)
v 48 v32 [no reg]: (*output)[21 - ++numDigits] [146; 148) (146 instr) (148 instr)
v 49 v33 [no reg]: (*output)[20] [158; 164) (158 instr) (160 instr) (164 instr)
v 50 v34 [no reg]: load (*output)[20] [160; 162) (160 instr) (162 instr)
v 51 v35 [no reg]: (*output)[20] + 1 [162; 164) (162 instr) (164 instr)
v 52 v36 [no reg]: (*result).ptr [170; 178) (170 instr) (178 instr)
v 53 v37 [no reg]: (*output).ptr [172; 176) (172 instr) (176 instr)
v 54 v38 [no reg]: 21 - numDigits [174; 176) (174 instr) (176 instr)
v 55 v39 [no reg]: (*output).ptr + (21 - numDigits) [176; 178) (176 instr) (178 instr)
v 56 v40 [no reg]: (*result).length [180; 182) (180 instr) (182 instr)
intervals formatInt
p 0 rax [rax]: [40; 41) [86; 88) [108; 112)
p 1 rcx [rcx]: [1; 2) [30; 41)
p 2 rdx [rdx]: [1; 4) [32; 41) [84; 90) [106; 110)
p 4 rsp [rsp]: [36; 44)
p 8 r8 [r8]: [1; 6) [34; 41)
p 9 r9 [r9]: [1; 8) [36; 41)
p 10 r10 [r10]: [40; 41)
p 11 r11 [r11]: [40; 41)
v 16 v0 [r8d]: [24; 33) (28 instr) child: v it59
v 17 v1 [rcx]: [62; 66) (64 instr) (66 phi)
v 18 v2 [rcx]: [72; 74) (74 phi)
v 19 v3 [r8d]: [76; 96) [116; 118) (96 instr) (118 phi)
v 20 v4 [rcx]: [76; 85) (78 instr) (82 instr) child: v it68
v 21 v5 [eax]: [120; 126) [136; 142) (122 instr) (126 instr) (138 phi) (142 instr)
v 22 v6 [eax]: [152; 166) (154 phi) (166 phi)
v 23 v7 [eax]: [168; 182) (174 instr) (182 instr)
v 24 v8 [rcx]: [2; 14) [50; 58) (2 instr) (14 instr) (52 instr) (54 phi) (58 instr)
v 25 v9 [rax]: [4; 39) (4 instr) (26 instr) child: v it57
v 26 v10 [r8d]: [6; 18) [50; 75) (6 instr) (18 instr) (18 phi) child: v it65
v 27 v11 [r9]: [8; 35) (8 instr) child: v it58
v 28 v12 [al]: [52; 85) (52 instr) (54 instr) child: v it63
v 29 v13 [rcx]: [26; 30) (26 instr) (30 instr)
v 30 v14 [edx]: [28; 32) (28 instr) (32 instr)
v 31 v15 [rax]: [44; 46) (44 instr) (46 instr)
v 32 v16 [rcx]: [58; 60) (58 instr) (60 phi)
v 33 v17 [dl]: [64; 83) (64 instr) (66 instr) child: v it64
v 34 v18 [rcx]: [86; 88) (86 instr) (88 instr)
v 35 v19 [rdx]: [90; 92) (90 instr) (92 instr)
v 36 v20 [rax]: [92; 94) (92 instr) (94 instr)
v 37 v21 [al]: [94; 102) (94 instr) (102 instr)
v 38 v22 [ecx]: [96; 114) (96 instr) (98 instr) (114 phi)
v 39 v23 [edx]: [98; 100) (98 instr) (100 instr)
v 40 v24 [rdx]: [100; 102) (100 instr) (102 instr)
v 41 v25 [r8]: [108; 110) (108 instr) (110 instr)
v 42 v26 [rax]: [112; 114) (112 instr) (114 phi)
v 43 v27 [eax]: [126; 134) (126 instr) (128 instr) (134 phi)
v 44 v28 [edx]: [128; 130) (128 instr) (130 instr)
v 45 v29 [rdx]: [130; 132) (130 instr) (132 instr)
v 46 v30 [eax]: [142; 150) (142 instr) (144 instr) (150 phi)
v 47 v31 [ecx]: [144; 146) (144 instr) (146 instr)
v 48 v32 [rcx]: [146; 148) (146 instr) (148 instr)
v 49 v33 [rcx]: [158; 164) (158 instr) (160 instr) (164 instr)
v 50 v34 [dl]: [160; 162) (160 instr) (162 instr)
v 51 v35 [dl]: [162; 164) (162 instr) (164 instr)
v 52 v36 [rcx]: [170; 178) (170 instr) (178 instr)
v 53 v37 [r8]: [172; 176) (172 instr) (176 instr)
v 54 v38 [r9d]: [174; 176) (174 instr) (176 instr)
v 55 v39 [r8]: [176; 178) (176 instr) (178 instr)
v 56 v40 [rcx]: [180; 182) (180 instr) (182 instr)
v 57 v9 [s2]: [40; 43) parent: v it25 child: v it62
v 58 v11 [s1]: [36; 169) parent: v it27 child: v it61
v 59 v0 [s0]: [34; 47) parent: v it16 child: v it60
v 60 v0 [eax]: [48; 48) (48 phi) parent: v it59
v 61 v11 [rdx]: [170; 180) (170 instr) (180 instr) parent: v it58
v 62 v9 [r9]: [44; 172) (44 instr) (100 instr) (130 instr) (146 instr) (158 instr) (172 instr) parent: v it57
v 63 v12 [s6]: [86; 137) parent: v it28 child: v it70
v 64 v17 [s4]: [84; 153) parent: v it33 child: v it67
v 65 v10 [s3]: [76; 121) parent: v it26 child: v it66
v 66 v10 [ecx]: [122; 134) (122 instr) parent: v it65
v 67 v17 [cl]: [154; 154) (154 instr) parent: v it64
v 68 v4 [s5]: [86; 103) parent: v it20 child: v it69
v 69 v4 [rax]: [104; 104) (104 instr) parent: v it68
v 70 v12 [cl]: [138; 138) (138 instr) parent: v it63
rax 71F5AFECA1 output
rcx 1 i
rdx 71F5AFECA1 output
r8d 0 minSize
r9d 00000071F5AFEBD0 result
void formatInt(i64 i, u8[21]* output, u32 minSize, u8[]* result)
// 0| | @0 SF.
// 2| 0| v8 i64 = mov rcx users [phi1, i5, i7, i22] // i
// 4| 1| v9 [21 x i8]* = mov rdx users [i66, i60, i56, i50, i10, i19, i38] // output
// 6| 2| v10 i32 = mov r8d users [i6, phi0, i47] // minSize
// 8| 3| v11 {i64, i8*}* = mov r9 users [i65, i70] // result
// 10| 4| jmp @2
{
u32 numDigits = 0;
// 12| | @2 SF. in(@0)
// 14| 5| if i64 v8 != i64 0 then @4 else @3 // i == 0
if (i == 0)
{
// 16| | @3 SF. in(@2)
// 18| 6| if i32 v10 == i32 0 then @5 else @6 // minSize v10
if (minSize == 0)
// 20| | @5 SF. in(@3)
// 22| 9| jmp @6
minSize = 1;
// 24| | @6 SF. in(@3, @5)
// 24| | v0 i32 = phi0(@3 i32 v10, @5 i32 1) users [i11, phi7]
// 26| 10| v13 i8* = mov [21 x i8]* v9 users [i12]
// 28| 11| v14 i32 = sub i32 21, i32 v0 users [i13]
// 30| 12| rcx = mov i8* v13
// 32| 13| edx = mov i32 v14
// 34| 14| r8 = mov i64 21
// 36| 15| r9b = mov i8 48
// 38| 16| rsp = sub rsp, i8 32
// 40| 17| call setRangeu8, rcx, edx, r8, r9b
// 42| 18| rsp = add rsp, i8 32
// 44| 19| v15 i8* = add [21 x i8]* v9, i8 20 users [i20]
// 46| 20| store i8* v15, i8 48
// 48| 21| jmp @20
setRangeu8((*output).ptr, 21 - minSize, 21, '0');
(*output)[20] = '0';
numDigits = minSize;
}
else
{
// 50| | @4 SF. in(@2)
// 52| 7| v12 i8 = set_binary_cond i64 v8, i64 0 users [i8, i53] // neg = i < 0
// 54| 8| if not i8 v12 then @7 else @8
bool neg = i < 0;
if (neg) {
i = -i;
// 56| | @7 SF. in(@4)
// 58| 22| v16 i64 = neg i64 v8 users [phi1]
// 60| 23| jmp @8
}
// 62| | @8 SF. in(@4, @7)
// 62| | v1 i64 = phi1(@4 i64 v8, @7 i64 v16) users [i24, phi2]
// 64| 24| v17 i8 = set_binary_cond i64 v1, i64 0 users [i25, i59] // overflow = i < 0
// 66| 25| if i8 v17 then @10 else @9
bool overflow = i < 0;
if (overflow)
// 68| | @9 SF. in(@8)
// 70| 26| jmp @10
i = i64.max;
// 72| | @10 SF. in(@8, @9)
// 72| | v2 i64 = phi2(@8 i64 v1, @9 i64 9223372036854775807) users [phi4]
// 74| 27| jmp @11
while (i)
// 76| | @11 SFL in(@10, @12)
// 76| | v4 i64 = phi4(@10 i64 v2, @12 i64 v26) users [i28, i29, i40] // v4 v2 v26 i
// 76| | v3 i32 = phi3(@10 i32 0, @12 i32 v22) users [i36, phi5] // v3 v22 numDigits
// 78| 28| if i64 v4 then @13 else @12
{
// 80| | @12 SF. in(@11)
// 82| 29| rax = mov i64 v4
// 84| 30| divsx
// 86| 31| v18 i64 = mov i64 10 users [i32] // 10
// 88| 32| rdx = idiv rdx, rax, i64 v18 // i % 10
// 90| 33| v19 i64 = mov rdx users [i34]
// 92| 34| v20 i64 = add i64 48, i64 v19 users [i35] // '0' + i % 10
// 94| 35| v21 i8 = mov i64 v20 users [i39] // cast(u8)('0' + i % 10)
u8 c = cast(u8)('0' + i % 10);
// 96| 36| v22 i32 = add i32 v3, i16 1 users [phi3, i37] // ++numDigits
// 98| 37| v23 i32 = sub i32 21, i32 v22 users [i38] // 21 - ++numDigits
// 100| 38| v24 i8* = add [21 x i8]* v9, i32 v23 users [i39]
// 102| 39| store i8* v24, i8 v21
// 104| 40| rax = mov i64 v4
// 106| 41| divsx
// 108| 42| v25 i64 = mov i64 10 users [i43]
// 110| 43| rax = idiv rdx, rax, i64 v25
// 112| 44| v26 i64 = mov rax users [phi4]
// 114| 45| jmp @11
(*output)[21 - ++numDigits] = c;
i /= 10;
}
// 116| | @13 SF. in(@11)
// 118| 46| jmp @14
// 120| | @14 SFL in(@13, @15)
// 120| | v5 i32 = phi5(@13 i32 v3, @15 i32 v27) users [phi6, i47, i48, i54]
// 122| 47| if i32 v5 >= i32 v10 then @16 else @15 // numDigits < minSize
while (numDigits < minSize) {
// 124| | @15 SF. in(@14)
// 126| 48| v27 i32 = add i32 v5, i16 1 users [phi5, i49]
// 128| 49| v28 i32 = sub i32 21, i32 v27 users [i50]
// 130| 50| v29 i8* = add [21 x i8]* v9, i32 v28 users [i51]
// 132| 51| store i8* v29, i8 48 // = '0'
// 134| 52| jmp @14
(*output)[21 - ++numDigits] = '0';
}
// 136| | @16 SF. in(@14)
// 138| 53| if i8 v12 then @18 else @17
if (neg) {
// 140| | @17 SF. in(@16)
// 142| 54| v30 i32 = add i32 v5, i16 1 users [i55, phi6]
// 144| 55| v31 i32 = sub i32 21, i32 v30 users [i56]
// 146| 56| v32 i8* = add [21 x i8]* v9, i32 v31 users [i57]
// 148| 57| store i8* v32, i8 45
// 150| 58| jmp @18
(*output)[21 - ++numDigits] = '-';
}
// 152| | @18 SF. in(@16, @17)
// 152| | v6 i32 = phi6(@16 i32 v5, @17 i32 v30) users [phi7, phi7]
// 154| 59| if i8 v17 then @20 else @19
if (overflow) {
// 156| | @19 SF. in(@18)
// 158| 60| v33 i8* = add [21 x i8]* v9, i8 20 users [i61, i63]
// 160| 61| v34 i8 = load i8* v33 users [i62]
// 162| 62| v35 i8 = add i8 v34, i16 1 users [i63]
// 164| 63| store i8* v33, i8 v35
// 166| 64| jmp @20
++(*output)[20];
}
}
// 168| | @20 SF. in(@6, @18, @19)
// 168| | v7 i32 = phi7(@6 i32 v0, @18 i32 v6, @19 i32 v6) users [i67, i71]
// 170| 65| v36 i8** = add {i64, i8*}* v11, i8 8 users [i69]
// 172| 66| v37 i8* = mov [21 x i8]* v9 users [i68]
// 174| 67| v38 i32 = sub i32 21, i32 v7 users [i68]
// 176| 68| v39 i8* = add i8* v37, i32 v38 users [i69]
// 178| 69| store i8** v36, i8* v39
(*result).ptr = (*output).ptr + (21 - numDigits);
// 180| 70| v40 i64* = mov {i64, i8*}* v11 users [i71]
// 182| 71| store i64* v40, i32 v7
(*result).length = numDigits;
// 184| 72| jmp @1
// 186| | @1 SF. in(@20)
// 188| 73| ret
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment