mirror of
https://gitlab.com/camelot/kickc.git
synced 2024-11-22 16:33:48 +00:00
Added missing ref files.
This commit is contained in:
jespergravgaard
parent
897cde29e4
commit
7bac2776b1
455
src/test/ref/multiply-16bit-const.asm
Normal file
455
src/test/ref/multiply-16bit-const.asm
Normal file
@ -0,0 +1,455 @@
|
||||
.pc = $801 "Basic"
|
||||
:BasicUpstart(main)
|
||||
.pc = $80d "Program"
|
||||
.label print_line_cursor = 6
|
||||
.label print_char_cursor = 6
|
||||
.label print_char_cursor_1 = $a
|
||||
.label print_line_cursor_1 = 8
|
||||
main: {
|
||||
.label i = 2
|
||||
.label __5 = $d
|
||||
.label __6 = $d
|
||||
.label __7 = $d
|
||||
.label __8 = $d
|
||||
.label __9 = $d
|
||||
.label __10 = $d
|
||||
.label __11 = $d
|
||||
// print_cls()
|
||||
jsr print_cls
|
||||
lda #<$400
|
||||
sta.z print_char_cursor
|
||||
lda #>$400
|
||||
sta.z print_char_cursor+1
|
||||
lda #<$400
|
||||
sta.z print_line_cursor_1
|
||||
lda #>$400
|
||||
sta.z print_line_cursor_1+1
|
||||
lda #<0
|
||||
sta.z i
|
||||
sta.z i+1
|
||||
lda #<0>>$10
|
||||
sta.z i+2
|
||||
lda #>0>>$10
|
||||
sta.z i+3
|
||||
__b1:
|
||||
// for(unsigned long i=0;i<3330;i+=333)
|
||||
lda.z i+3
|
||||
cmp #>$d02>>$10
|
||||
bcc __b2
|
||||
bne !+
|
||||
lda.z i+2
|
||||
cmp #<$d02>>$10
|
||||
bcc __b2
|
||||
bne !+
|
||||
lda.z i+1
|
||||
cmp #>$d02
|
||||
bcc __b2
|
||||
bne !+
|
||||
lda.z i
|
||||
cmp #<$d02
|
||||
bcc __b2
|
||||
!:
|
||||
// }
|
||||
rts
|
||||
__b2:
|
||||
// print_ulong_decimal(i*555)
|
||||
lda.z i
|
||||
asl
|
||||
sta.z __5
|
||||
lda.z i+1
|
||||
rol
|
||||
sta.z __5+1
|
||||
lda.z i+2
|
||||
rol
|
||||
sta.z __5+2
|
||||
lda.z i+3
|
||||
rol
|
||||
sta.z __5+3
|
||||
asl.z __5
|
||||
rol.z __5+1
|
||||
rol.z __5+2
|
||||
rol.z __5+3
|
||||
asl.z __5
|
||||
rol.z __5+1
|
||||
rol.z __5+2
|
||||
rol.z __5+3
|
||||
asl.z __5
|
||||
rol.z __5+1
|
||||
rol.z __5+2
|
||||
rol.z __5+3
|
||||
lda.z __6
|
||||
clc
|
||||
adc.z i
|
||||
sta.z __6
|
||||
lda.z __6+1
|
||||
adc.z i+1
|
||||
sta.z __6+1
|
||||
lda.z __6+2
|
||||
adc.z i+2
|
||||
sta.z __6+2
|
||||
lda.z __6+3
|
||||
adc.z i+3
|
||||
sta.z __6+3
|
||||
asl.z __7
|
||||
rol.z __7+1
|
||||
rol.z __7+2
|
||||
rol.z __7+3
|
||||
asl.z __7
|
||||
rol.z __7+1
|
||||
rol.z __7+2
|
||||
rol.z __7+3
|
||||
lda.z __8
|
||||
clc
|
||||
adc.z i
|
||||
sta.z __8
|
||||
lda.z __8+1
|
||||
adc.z i+1
|
||||
sta.z __8+1
|
||||
lda.z __8+2
|
||||
adc.z i+2
|
||||
sta.z __8+2
|
||||
lda.z __8+3
|
||||
adc.z i+3
|
||||
sta.z __8+3
|
||||
asl.z __9
|
||||
rol.z __9+1
|
||||
rol.z __9+2
|
||||
rol.z __9+3
|
||||
asl.z __9
|
||||
rol.z __9+1
|
||||
rol.z __9+2
|
||||
rol.z __9+3
|
||||
lda.z __10
|
||||
clc
|
||||
adc.z i
|
||||
sta.z __10
|
||||
lda.z __10+1
|
||||
adc.z i+1
|
||||
sta.z __10+1
|
||||
lda.z __10+2
|
||||
adc.z i+2
|
||||
sta.z __10+2
|
||||
lda.z __10+3
|
||||
adc.z i+3
|
||||
sta.z __10+3
|
||||
asl.z __11
|
||||
rol.z __11+1
|
||||
rol.z __11+2
|
||||
rol.z __11+3
|
||||
lda.z print_ulong_decimal.w
|
||||
clc
|
||||
adc.z i
|
||||
sta.z print_ulong_decimal.w
|
||||
lda.z print_ulong_decimal.w+1
|
||||
adc.z i+1
|
||||
sta.z print_ulong_decimal.w+1
|
||||
lda.z print_ulong_decimal.w+2
|
||||
adc.z i+2
|
||||
sta.z print_ulong_decimal.w+2
|
||||
lda.z print_ulong_decimal.w+3
|
||||
adc.z i+3
|
||||
sta.z print_ulong_decimal.w+3
|
||||
jsr print_ulong_decimal
|
||||
// print_ln()
|
||||
jsr print_ln
|
||||
// i+=333
|
||||
lda.z i
|
||||
clc
|
||||
adc #<$14d
|
||||
sta.z i
|
||||
lda.z i+1
|
||||
adc #>$14d
|
||||
sta.z i+1
|
||||
lda.z i+2
|
||||
adc #0
|
||||
sta.z i+2
|
||||
lda.z i+3
|
||||
adc #0
|
||||
sta.z i+3
|
||||
lda.z print_line_cursor
|
||||
sta.z print_line_cursor_1
|
||||
lda.z print_line_cursor+1
|
||||
sta.z print_line_cursor_1+1
|
||||
jmp __b1
|
||||
}
|
||||
// Print a newline
|
||||
print_ln: {
|
||||
__b1:
|
||||
// print_line_cursor + $28
|
||||
lda #$28
|
||||
clc
|
||||
adc.z print_line_cursor_1
|
||||
sta.z print_line_cursor
|
||||
lda #0
|
||||
adc.z print_line_cursor_1+1
|
||||
sta.z print_line_cursor+1
|
||||
// while (print_line_cursor<print_char_cursor)
|
||||
cmp.z print_char_cursor_1+1
|
||||
bcc __b2
|
||||
bne !+
|
||||
lda.z print_line_cursor
|
||||
cmp.z print_char_cursor_1
|
||||
bcc __b2
|
||||
!:
|
||||
// }
|
||||
rts
|
||||
__b2:
|
||||
lda.z print_line_cursor
|
||||
sta.z print_line_cursor_1
|
||||
lda.z print_line_cursor+1
|
||||
sta.z print_line_cursor_1+1
|
||||
jmp __b1
|
||||
}
|
||||
// Print a unsigned long as DECIMAL
|
||||
// print_ulong_decimal(dword zp($d) w)
|
||||
print_ulong_decimal: {
|
||||
.label w = $d
|
||||
// ultoa(w, decimal_digits_long, DECIMAL)
|
||||
jsr ultoa
|
||||
// print_str(decimal_digits_long)
|
||||
jsr print_str
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// Print a zero-terminated string
|
||||
// print_str(byte* zp($11) str)
|
||||
print_str: {
|
||||
.label str = $11
|
||||
lda.z print_char_cursor
|
||||
sta.z print_char_cursor_1
|
||||
lda.z print_char_cursor+1
|
||||
sta.z print_char_cursor_1+1
|
||||
lda #<decimal_digits_long
|
||||
sta.z str
|
||||
lda #>decimal_digits_long
|
||||
sta.z str+1
|
||||
__b1:
|
||||
// while(*str)
|
||||
ldy #0
|
||||
lda (str),y
|
||||
cmp #0
|
||||
bne __b2
|
||||
// }
|
||||
rts
|
||||
__b2:
|
||||
// print_char(*(str++))
|
||||
ldy #0
|
||||
lda (str),y
|
||||
jsr print_char
|
||||
// print_char(*(str++));
|
||||
inc.z str
|
||||
bne !+
|
||||
inc.z str+1
|
||||
!:
|
||||
jmp __b1
|
||||
}
|
||||
// Print a single char
|
||||
// print_char(byte register(A) ch)
|
||||
print_char: {
|
||||
// *(print_char_cursor++) = ch
|
||||
ldy #0
|
||||
sta (print_char_cursor_1),y
|
||||
// *(print_char_cursor++) = ch;
|
||||
inc.z print_char_cursor_1
|
||||
bne !+
|
||||
inc.z print_char_cursor_1+1
|
||||
!:
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// Converts unsigned number value to a string representing it in RADIX format.
|
||||
// If the leading digits are zero they are not included in the string.
|
||||
// - value : The number to be converted to RADIX
|
||||
// - buffer : receives the string representing the number and zero-termination.
|
||||
// - radix : The radix to convert the number to (from the enum RADIX)
|
||||
// ultoa(dword zp($d) value, byte* zp($11) buffer)
|
||||
ultoa: {
|
||||
.const max_digits = $a
|
||||
.label digit_value = $13
|
||||
.label buffer = $11
|
||||
.label digit = $c
|
||||
.label value = $d
|
||||
lda #<decimal_digits_long
|
||||
sta.z buffer
|
||||
lda #>decimal_digits_long
|
||||
sta.z buffer+1
|
||||
ldx #0
|
||||
txa
|
||||
sta.z digit
|
||||
__b1:
|
||||
// for( char digit=0; digit<max_digits-1; digit++ )
|
||||
lda.z digit
|
||||
cmp #max_digits-1
|
||||
bcc __b2
|
||||
// (char)value
|
||||
lda.z value
|
||||
// *buffer++ = DIGITS[(char)value]
|
||||
tay
|
||||
lda DIGITS,y
|
||||
ldy #0
|
||||
sta (buffer),y
|
||||
// *buffer++ = DIGITS[(char)value];
|
||||
inc.z buffer
|
||||
bne !+
|
||||
inc.z buffer+1
|
||||
!:
|
||||
// *buffer = 0
|
||||
lda #0
|
||||
tay
|
||||
sta (buffer),y
|
||||
// }
|
||||
rts
|
||||
__b2:
|
||||
// digit_value = digit_values[digit]
|
||||
lda.z digit
|
||||
asl
|
||||
asl
|
||||
tay
|
||||
lda RADIX_DECIMAL_VALUES_LONG,y
|
||||
sta.z digit_value
|
||||
lda RADIX_DECIMAL_VALUES_LONG+1,y
|
||||
sta.z digit_value+1
|
||||
lda RADIX_DECIMAL_VALUES_LONG+2,y
|
||||
sta.z digit_value+2
|
||||
lda RADIX_DECIMAL_VALUES_LONG+3,y
|
||||
sta.z digit_value+3
|
||||
// if (started || value >= digit_value)
|
||||
cpx #0
|
||||
bne __b5
|
||||
lda.z value+3
|
||||
cmp.z digit_value+3
|
||||
bcc !+
|
||||
bne __b5
|
||||
lda.z value+2
|
||||
cmp.z digit_value+2
|
||||
bcc !+
|
||||
bne __b5
|
||||
lda.z value+1
|
||||
cmp.z digit_value+1
|
||||
bcc !+
|
||||
bne __b5
|
||||
lda.z value
|
||||
cmp.z digit_value
|
||||
bcs __b5
|
||||
!:
|
||||
__b4:
|
||||
// for( char digit=0; digit<max_digits-1; digit++ )
|
||||
inc.z digit
|
||||
jmp __b1
|
||||
__b5:
|
||||
// ultoa_append(buffer++, value, digit_value)
|
||||
jsr ultoa_append
|
||||
// ultoa_append(buffer++, value, digit_value)
|
||||
// value = ultoa_append(buffer++, value, digit_value)
|
||||
// value = ultoa_append(buffer++, value, digit_value);
|
||||
inc.z buffer
|
||||
bne !+
|
||||
inc.z buffer+1
|
||||
!:
|
||||
ldx #1
|
||||
jmp __b4
|
||||
}
|
||||
// Used to convert a single digit of an unsigned number value to a string representation
|
||||
// Counts a single digit up from '0' as long as the value is larger than sub.
|
||||
// Each time the digit is increased sub is subtracted from value.
|
||||
// - buffer : pointer to the char that receives the digit
|
||||
// - value : The value where the digit will be derived from
|
||||
// - sub : the value of a '1' in the digit. Subtracted continually while the digit is increased.
|
||||
// (For decimal the subs used are 10000, 1000, 100, 10, 1)
|
||||
// returns : the value reduced by sub * digit so that it is less than sub.
|
||||
// ultoa_append(byte* zp($11) buffer, dword zp($d) value, dword zp($13) sub)
|
||||
ultoa_append: {
|
||||
.label buffer = $11
|
||||
.label value = $d
|
||||
.label sub = $13
|
||||
.label return = $d
|
||||
ldx #0
|
||||
__b1:
|
||||
// while (value >= sub)
|
||||
lda.z value+3
|
||||
cmp.z sub+3
|
||||
bcc !+
|
||||
bne __b2
|
||||
lda.z value+2
|
||||
cmp.z sub+2
|
||||
bcc !+
|
||||
bne __b2
|
||||
lda.z value+1
|
||||
cmp.z sub+1
|
||||
bcc !+
|
||||
bne __b2
|
||||
lda.z value
|
||||
cmp.z sub
|
||||
bcs __b2
|
||||
!:
|
||||
// *buffer = DIGITS[digit]
|
||||
lda DIGITS,x
|
||||
ldy #0
|
||||
sta (buffer),y
|
||||
// }
|
||||
rts
|
||||
__b2:
|
||||
// digit++;
|
||||
inx
|
||||
// value -= sub
|
||||
lda.z value
|
||||
sec
|
||||
sbc.z sub
|
||||
sta.z value
|
||||
lda.z value+1
|
||||
sbc.z sub+1
|
||||
sta.z value+1
|
||||
lda.z value+2
|
||||
sbc.z sub+2
|
||||
sta.z value+2
|
||||
lda.z value+3
|
||||
sbc.z sub+3
|
||||
sta.z value+3
|
||||
jmp __b1
|
||||
}
|
||||
// Clear the screen. Also resets current line/char cursor.
|
||||
print_cls: {
|
||||
// memset(print_screen, ' ', 1000)
|
||||
jsr memset
|
||||
// }
|
||||
rts
|
||||
}
|
||||
// Copies the character c (an unsigned char) to the first num characters of the object pointed to by the argument str.
|
||||
memset: {
|
||||
.const c = ' '
|
||||
.const num = $3e8
|
||||
.label str = $400
|
||||
.label end = str+num
|
||||
.label dst = $11
|
||||
lda #<str
|
||||
sta.z dst
|
||||
lda #>str
|
||||
sta.z dst+1
|
||||
__b1:
|
||||
// for(char* dst = str; dst!=end; dst++)
|
||||
lda.z dst+1
|
||||
cmp #>end
|
||||
bne __b2
|
||||
lda.z dst
|
||||
cmp #<end
|
||||
bne __b2
|
||||
// }
|
||||
rts
|
||||
__b2:
|
||||
// *dst = c
|
||||
lda #c
|
||||
ldy #0
|
||||
sta (dst),y
|
||||
// for(char* dst = str; dst!=end; dst++)
|
||||
inc.z dst
|
||||
bne !+
|
||||
inc.z dst+1
|
||||
!:
|
||||
jmp __b1
|
||||
}
|
||||
// The digits used for numbers
|
||||
DIGITS: .text "0123456789abcdef"
|
||||
// Values of decimal digits
|
||||
RADIX_DECIMAL_VALUES_LONG: .dword $3b9aca00, $5f5e100, $989680, $f4240, $186a0, $2710, $3e8, $64, $a
|
||||
// Digits used for storing the decimal unsigned int
|
||||
decimal_digits_long: .fill $b, 0
|
||||
192
src/test/ref/multiply-16bit-const.cfg
Normal file
192
src/test/ref/multiply-16bit-const.cfg
Normal file
@ -0,0 +1,192 @@
|
||||
@begin: scope:[] from
|
||||
[0] phi()
|
||||
to:@1
|
||||
@1: scope:[] from @begin
|
||||
[1] phi()
|
||||
[2] call main
|
||||
to:@end
|
||||
@end: scope:[] from @1
|
||||
[3] phi()
|
||||
|
||||
(void()) main()
|
||||
main: scope:[main] from @1
|
||||
[4] phi()
|
||||
[5] call print_cls
|
||||
to:main::@1
|
||||
main::@1: scope:[main] from main main::@4
|
||||
[6] (byte*) print_char_cursor#14 ← phi( main/(byte*) 1024 main::@4/(byte*) print_line_cursor#1 )
|
||||
[6] (byte*) print_line_cursor#15 ← phi( main/(byte*) 1024 main::@4/(byte*) print_line_cursor#25 )
|
||||
[6] (dword) main::i#2 ← phi( main/(dword) 0 main::@4/(dword) main::i#1 )
|
||||
[7] if((dword) main::i#2<(word) $d02) goto main::@2
|
||||
to:main::@return
|
||||
main::@return: scope:[main] from main::@1
|
||||
[8] return
|
||||
to:@return
|
||||
main::@2: scope:[main] from main::@1
|
||||
[9] (dword~) main::$5 ← (dword) main::i#2 << (byte) 4
|
||||
[10] (dword~) main::$6 ← (dword~) main::$5 + (dword) main::i#2
|
||||
[11] (dword~) main::$7 ← (dword~) main::$6 << (byte) 2
|
||||
[12] (dword~) main::$8 ← (dword~) main::$7 + (dword) main::i#2
|
||||
[13] (dword~) main::$9 ← (dword~) main::$8 << (byte) 2
|
||||
[14] (dword~) main::$10 ← (dword~) main::$9 + (dword) main::i#2
|
||||
[15] (dword~) main::$11 ← (dword~) main::$10 << (byte) 1
|
||||
[16] (dword) print_ulong_decimal::w#0 ← (dword~) main::$11 + (dword) main::i#2
|
||||
[17] call print_ulong_decimal
|
||||
to:main::@3
|
||||
main::@3: scope:[main] from main::@2
|
||||
[18] phi()
|
||||
[19] call print_ln
|
||||
to:main::@4
|
||||
main::@4: scope:[main] from main::@3
|
||||
[20] (dword) main::i#1 ← (dword) main::i#2 + (word) $14d
|
||||
[21] (byte*) print_line_cursor#25 ← (byte*) print_line_cursor#1
|
||||
to:main::@1
|
||||
|
||||
(void()) print_ln()
|
||||
print_ln: scope:[print_ln] from main::@3
|
||||
[22] phi()
|
||||
to:print_ln::@1
|
||||
print_ln::@1: scope:[print_ln] from print_ln print_ln::@2
|
||||
[23] (byte*) print_line_cursor#9 ← phi( print_ln/(byte*) print_line_cursor#15 print_ln::@2/(byte*) print_line_cursor#24 )
|
||||
[24] (byte*) print_line_cursor#1 ← (byte*) print_line_cursor#9 + (byte) $28
|
||||
[25] if((byte*) print_line_cursor#1<(byte*) print_char_cursor#17) goto print_ln::@2
|
||||
to:print_ln::@return
|
||||
print_ln::@return: scope:[print_ln] from print_ln::@1
|
||||
[26] return
|
||||
to:@return
|
||||
print_ln::@2: scope:[print_ln] from print_ln::@1
|
||||
[27] (byte*) print_line_cursor#24 ← (byte*) print_line_cursor#1
|
||||
to:print_ln::@1
|
||||
|
||||
(void()) print_ulong_decimal((dword) print_ulong_decimal::w)
|
||||
print_ulong_decimal: scope:[print_ulong_decimal] from main::@2
|
||||
[28] (dword) ultoa::value#1 ← (dword) print_ulong_decimal::w#0
|
||||
[29] call ultoa
|
||||
to:print_ulong_decimal::@1
|
||||
print_ulong_decimal::@1: scope:[print_ulong_decimal] from print_ulong_decimal
|
||||
[30] phi()
|
||||
[31] call print_str
|
||||
to:print_ulong_decimal::@return
|
||||
print_ulong_decimal::@return: scope:[print_ulong_decimal] from print_ulong_decimal::@1
|
||||
[32] return
|
||||
to:@return
|
||||
|
||||
(void()) print_str((byte*) print_str::str)
|
||||
print_str: scope:[print_str] from print_ulong_decimal::@1
|
||||
[33] (byte*) print_char_cursor#40 ← (byte*) print_char_cursor#14
|
||||
to:print_str::@1
|
||||
print_str::@1: scope:[print_str] from print_str print_str::@3
|
||||
[34] (byte*) print_char_cursor#17 ← phi( print_str/(byte*) print_char_cursor#40 print_str::@3/(byte*) print_char_cursor#23 )
|
||||
[34] (byte*) print_str::str#2 ← phi( print_str/(const byte*) decimal_digits_long print_str::@3/(byte*) print_str::str#0 )
|
||||
[35] if((byte) 0!=*((byte*) print_str::str#2)) goto print_str::@2
|
||||
to:print_str::@return
|
||||
print_str::@return: scope:[print_str] from print_str::@1
|
||||
[36] return
|
||||
to:@return
|
||||
print_str::@2: scope:[print_str] from print_str::@1
|
||||
[37] (byte) print_char::ch#0 ← *((byte*) print_str::str#2)
|
||||
[38] call print_char
|
||||
to:print_str::@3
|
||||
print_str::@3: scope:[print_str] from print_str::@2
|
||||
[39] (byte*) print_str::str#0 ← ++ (byte*) print_str::str#2
|
||||
to:print_str::@1
|
||||
|
||||
(void()) print_char((byte) print_char::ch)
|
||||
print_char: scope:[print_char] from print_str::@2
|
||||
[40] *((byte*) print_char_cursor#17) ← (byte) print_char::ch#0
|
||||
[41] (byte*) print_char_cursor#23 ← ++ (byte*) print_char_cursor#17
|
||||
to:print_char::@return
|
||||
print_char::@return: scope:[print_char] from print_char
|
||||
[42] return
|
||||
to:@return
|
||||
|
||||
(void()) ultoa((dword) ultoa::value , (byte*) ultoa::buffer , (byte) ultoa::radix)
|
||||
ultoa: scope:[ultoa] from print_ulong_decimal
|
||||
[43] phi()
|
||||
to:ultoa::@1
|
||||
ultoa::@1: scope:[ultoa] from ultoa ultoa::@4
|
||||
[44] (byte*) ultoa::buffer#11 ← phi( ultoa::@4/(byte*) ultoa::buffer#14 ultoa/(const byte*) decimal_digits_long )
|
||||
[44] (byte) ultoa::started#2 ← phi( ultoa::@4/(byte) ultoa::started#4 ultoa/(byte) 0 )
|
||||
[44] (dword) ultoa::value#2 ← phi( ultoa::@4/(dword) ultoa::value#6 ultoa/(dword) ultoa::value#1 )
|
||||
[44] (byte) ultoa::digit#2 ← phi( ultoa::@4/(byte) ultoa::digit#1 ultoa/(byte) 0 )
|
||||
[45] if((byte) ultoa::digit#2<(const byte) ultoa::max_digits#1-(byte) 1) goto ultoa::@2
|
||||
to:ultoa::@3
|
||||
ultoa::@3: scope:[ultoa] from ultoa::@1
|
||||
[46] (byte~) ultoa::$4 ← (byte)(dword) ultoa::value#2
|
||||
[47] *((byte*) ultoa::buffer#11) ← *((const byte*) DIGITS + (byte~) ultoa::$4)
|
||||
[48] (byte*) ultoa::buffer#3 ← ++ (byte*) ultoa::buffer#11
|
||||
[49] *((byte*) ultoa::buffer#3) ← (byte) 0
|
||||
to:ultoa::@return
|
||||
ultoa::@return: scope:[ultoa] from ultoa::@3
|
||||
[50] return
|
||||
to:@return
|
||||
ultoa::@2: scope:[ultoa] from ultoa::@1
|
||||
[51] (byte~) ultoa::$11 ← (byte) ultoa::digit#2 << (byte) 2
|
||||
[52] (dword) ultoa::digit_value#0 ← *((const dword*) RADIX_DECIMAL_VALUES_LONG + (byte~) ultoa::$11)
|
||||
[53] if((byte) 0!=(byte) ultoa::started#2) goto ultoa::@5
|
||||
to:ultoa::@7
|
||||
ultoa::@7: scope:[ultoa] from ultoa::@2
|
||||
[54] if((dword) ultoa::value#2>=(dword) ultoa::digit_value#0) goto ultoa::@5
|
||||
to:ultoa::@4
|
||||
ultoa::@4: scope:[ultoa] from ultoa::@6 ultoa::@7
|
||||
[55] (byte*) ultoa::buffer#14 ← phi( ultoa::@7/(byte*) ultoa::buffer#11 ultoa::@6/(byte*) ultoa::buffer#4 )
|
||||
[55] (byte) ultoa::started#4 ← phi( ultoa::@7/(byte) ultoa::started#2 ultoa::@6/(byte) 1 )
|
||||
[55] (dword) ultoa::value#6 ← phi( ultoa::@7/(dword) ultoa::value#2 ultoa::@6/(dword) ultoa::value#0 )
|
||||
[56] (byte) ultoa::digit#1 ← ++ (byte) ultoa::digit#2
|
||||
to:ultoa::@1
|
||||
ultoa::@5: scope:[ultoa] from ultoa::@2 ultoa::@7
|
||||
[57] (byte*) ultoa_append::buffer#0 ← (byte*) ultoa::buffer#11
|
||||
[58] (dword) ultoa_append::value#0 ← (dword) ultoa::value#2
|
||||
[59] (dword) ultoa_append::sub#0 ← (dword) ultoa::digit_value#0
|
||||
[60] call ultoa_append
|
||||
[61] (dword) ultoa_append::return#0 ← (dword) ultoa_append::value#2
|
||||
to:ultoa::@6
|
||||
ultoa::@6: scope:[ultoa] from ultoa::@5
|
||||
[62] (dword) ultoa::value#0 ← (dword) ultoa_append::return#0
|
||||
[63] (byte*) ultoa::buffer#4 ← ++ (byte*) ultoa::buffer#11
|
||||
to:ultoa::@4
|
||||
|
||||
(dword()) ultoa_append((byte*) ultoa_append::buffer , (dword) ultoa_append::value , (dword) ultoa_append::sub)
|
||||
ultoa_append: scope:[ultoa_append] from ultoa::@5
|
||||
[64] phi()
|
||||
to:ultoa_append::@1
|
||||
ultoa_append::@1: scope:[ultoa_append] from ultoa_append ultoa_append::@2
|
||||
[65] (byte) ultoa_append::digit#2 ← phi( ultoa_append/(byte) 0 ultoa_append::@2/(byte) ultoa_append::digit#1 )
|
||||
[65] (dword) ultoa_append::value#2 ← phi( ultoa_append/(dword) ultoa_append::value#0 ultoa_append::@2/(dword) ultoa_append::value#1 )
|
||||
[66] if((dword) ultoa_append::value#2>=(dword) ultoa_append::sub#0) goto ultoa_append::@2
|
||||
to:ultoa_append::@3
|
||||
ultoa_append::@3: scope:[ultoa_append] from ultoa_append::@1
|
||||
[67] *((byte*) ultoa_append::buffer#0) ← *((const byte*) DIGITS + (byte) ultoa_append::digit#2)
|
||||
to:ultoa_append::@return
|
||||
ultoa_append::@return: scope:[ultoa_append] from ultoa_append::@3
|
||||
[68] return
|
||||
to:@return
|
||||
ultoa_append::@2: scope:[ultoa_append] from ultoa_append::@1
|
||||
[69] (byte) ultoa_append::digit#1 ← ++ (byte) ultoa_append::digit#2
|
||||
[70] (dword) ultoa_append::value#1 ← (dword) ultoa_append::value#2 - (dword) ultoa_append::sub#0
|
||||
to:ultoa_append::@1
|
||||
|
||||
(void()) print_cls()
|
||||
print_cls: scope:[print_cls] from main
|
||||
[71] phi()
|
||||
[72] call memset
|
||||
to:print_cls::@return
|
||||
print_cls::@return: scope:[print_cls] from print_cls
|
||||
[73] return
|
||||
to:@return
|
||||
|
||||
(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
|
||||
memset: scope:[memset] from print_cls
|
||||
[74] phi()
|
||||
to:memset::@1
|
||||
memset::@1: scope:[memset] from memset memset::@2
|
||||
[75] (byte*) memset::dst#2 ← phi( memset/(byte*)(const void*) memset::str#0 memset::@2/(byte*) memset::dst#1 )
|
||||
[76] if((byte*) memset::dst#2!=(const byte*) memset::end#0) goto memset::@2
|
||||
to:memset::@return
|
||||
memset::@return: scope:[memset] from memset::@1
|
||||
[77] return
|
||||
to:@return
|
||||
memset::@2: scope:[memset] from memset::@1
|
||||
[78] *((byte*) memset::dst#2) ← (const byte) memset::c#0
|
||||
[79] (byte*) memset::dst#1 ← ++ (byte*) memset::dst#2
|
||||
to:memset::@1
|
||||
3970
src/test/ref/multiply-16bit-const.log
Normal file
3970
src/test/ref/multiply-16bit-const.log
Normal file
File diff suppressed because it is too large
Load Diff
142
src/test/ref/multiply-16bit-const.sym
Normal file
142
src/test/ref/multiply-16bit-const.sym
Normal file
@ -0,0 +1,142 @@
|
||||
(label) @1
|
||||
(label) @begin
|
||||
(label) @end
|
||||
(const byte*) DIGITS[] = (byte*) "0123456789abcdef"z
|
||||
(const byte) RADIX::BINARY = (number) 2
|
||||
(const byte) RADIX::DECIMAL = (number) $a
|
||||
(const byte) RADIX::HEXADECIMAL = (number) $10
|
||||
(const byte) RADIX::OCTAL = (number) 8
|
||||
(const dword*) RADIX_DECIMAL_VALUES_LONG[] = { (dword) $3b9aca00, (dword) $5f5e100, (dword) $989680, (dword) $f4240, (dword) $186a0, (dword) $2710, (dword) $3e8, (dword) $64, (dword) $a }
|
||||
(const byte*) decimal_digits_long[(number) $b] = { fill( $b, 0) }
|
||||
(void()) main()
|
||||
(dword~) main::$10 zp[4]:13 202.0
|
||||
(dword~) main::$11 zp[4]:13 202.0
|
||||
(dword~) main::$5 zp[4]:13 202.0
|
||||
(dword~) main::$6 zp[4]:13 202.0
|
||||
(dword~) main::$7 zp[4]:13 202.0
|
||||
(dword~) main::$8 zp[4]:13 202.0
|
||||
(dword~) main::$9 zp[4]:13 202.0
|
||||
(label) main::@1
|
||||
(label) main::@2
|
||||
(label) main::@3
|
||||
(label) main::@4
|
||||
(label) main::@return
|
||||
(dword) main::i
|
||||
(dword) main::i#1 i zp[4]:2 101.0
|
||||
(dword) main::i#2 i zp[4]:2 62.153846153846146
|
||||
(void*()) memset((void*) memset::str , (byte) memset::c , (word) memset::num)
|
||||
(label) memset::@1
|
||||
(label) memset::@2
|
||||
(label) memset::@return
|
||||
(byte) memset::c
|
||||
(const byte) memset::c#0 c = (byte) ' '
|
||||
(byte*) memset::dst
|
||||
(byte*) memset::dst#1 dst zp[2]:17 20002.0
|
||||
(byte*) memset::dst#2 dst zp[2]:17 13334.666666666666
|
||||
(byte*) memset::end
|
||||
(const byte*) memset::end#0 end = (byte*)(const void*) memset::str#0+(const word) memset::num#0
|
||||
(word) memset::num
|
||||
(const word) memset::num#0 num = (word) $3e8
|
||||
(void*) memset::return
|
||||
(void*) memset::str
|
||||
(const void*) memset::str#0 str = (void*)(byte*) 1024
|
||||
(void()) print_char((byte) print_char::ch)
|
||||
(label) print_char::@return
|
||||
(byte) print_char::ch
|
||||
(byte) print_char::ch#0 reg byte a 1.1000002E7
|
||||
(byte*) print_char_cursor
|
||||
(byte*) print_char_cursor#14 print_char_cursor zp[2]:6 777.076923076923
|
||||
(byte*) print_char_cursor#17 print_char_cursor_1 zp[2]:10 1507857.5
|
||||
(byte*) print_char_cursor#23 print_char_cursor_1 zp[2]:10 2750000.5
|
||||
(byte*) print_char_cursor#40 print_char_cursor_1 zp[2]:10 20002.0
|
||||
(void()) print_cls()
|
||||
(label) print_cls::@return
|
||||
(byte*) print_line_cursor
|
||||
(byte*) print_line_cursor#1 print_line_cursor zp[2]:6 50034.16666666666
|
||||
(byte*) print_line_cursor#15 print_line_cursor_1 zp[2]:8 84.76923076923077
|
||||
(byte*) print_line_cursor#24 print_line_cursor_1 zp[2]:8 200002.0
|
||||
(byte*) print_line_cursor#25 print_line_cursor_1 zp[2]:8 202.0
|
||||
(byte*) print_line_cursor#9 print_line_cursor_1 zp[2]:8 201003.0
|
||||
(void()) print_ln()
|
||||
(label) print_ln::@1
|
||||
(label) print_ln::@2
|
||||
(label) print_ln::@return
|
||||
(byte*) print_screen
|
||||
(void()) print_str((byte*) print_str::str)
|
||||
(label) print_str::@1
|
||||
(label) print_str::@2
|
||||
(label) print_str::@3
|
||||
(label) print_str::@return
|
||||
(byte*) print_str::str
|
||||
(byte*) print_str::str#0 str zp[2]:17 2000002.0
|
||||
(byte*) print_str::str#2 str zp[2]:17 1000001.0
|
||||
(void()) print_ulong_decimal((dword) print_ulong_decimal::w)
|
||||
(label) print_ulong_decimal::@1
|
||||
(label) print_ulong_decimal::@return
|
||||
(dword) print_ulong_decimal::w
|
||||
(dword) print_ulong_decimal::w#0 w zp[4]:13 1102.0
|
||||
(void()) ultoa((dword) ultoa::value , (byte*) ultoa::buffer , (byte) ultoa::radix)
|
||||
(byte~) ultoa::$11 reg byte a 2000002.0
|
||||
(byte~) ultoa::$4 reg byte a 20002.0
|
||||
(label) ultoa::@1
|
||||
(label) ultoa::@2
|
||||
(label) ultoa::@3
|
||||
(label) ultoa::@4
|
||||
(label) ultoa::@5
|
||||
(label) ultoa::@6
|
||||
(label) ultoa::@7
|
||||
(label) ultoa::@return
|
||||
(byte*) ultoa::buffer
|
||||
(byte*) ultoa::buffer#11 buffer zp[2]:17 287143.2857142857
|
||||
(byte*) ultoa::buffer#14 buffer zp[2]:17 1500001.5
|
||||
(byte*) ultoa::buffer#3 buffer zp[2]:17 20002.0
|
||||
(byte*) ultoa::buffer#4 buffer zp[2]:17 2000002.0
|
||||
(byte) ultoa::digit
|
||||
(byte) ultoa::digit#1 digit zp[1]:12 2000002.0
|
||||
(byte) ultoa::digit#2 digit zp[1]:12 285714.5714285714
|
||||
(dword) ultoa::digit_value
|
||||
(dword) ultoa::digit_value#0 digit_value zp[4]:19 600000.6000000001
|
||||
(dword*) ultoa::digit_values
|
||||
(byte) ultoa::max_digits
|
||||
(const byte) ultoa::max_digits#1 max_digits = (byte) $a
|
||||
(byte) ultoa::radix
|
||||
(byte) ultoa::started
|
||||
(byte) ultoa::started#2 reg byte x 500000.5
|
||||
(byte) ultoa::started#4 reg byte x 1000001.0
|
||||
(dword) ultoa::value
|
||||
(dword) ultoa::value#0 value zp[4]:13 1000001.0
|
||||
(dword) ultoa::value#1 value zp[4]:13 5501.0
|
||||
(dword) ultoa::value#2 value zp[4]:13 572857.857142857
|
||||
(dword) ultoa::value#6 value zp[4]:13 1500001.5
|
||||
(dword()) ultoa_append((byte*) ultoa_append::buffer , (dword) ultoa_append::value , (dword) ultoa_append::sub)
|
||||
(label) ultoa_append::@1
|
||||
(label) ultoa_append::@2
|
||||
(label) ultoa_append::@3
|
||||
(label) ultoa_append::@return
|
||||
(byte*) ultoa_append::buffer
|
||||
(byte*) ultoa_append::buffer#0 buffer zp[2]:17 1375000.25
|
||||
(byte) ultoa_append::digit
|
||||
(byte) ultoa_append::digit#1 reg byte x 1.0000000001E10
|
||||
(byte) ultoa_append::digit#2 reg byte x 1.00050000015E10
|
||||
(dword) ultoa_append::return
|
||||
(dword) ultoa_append::return#0 return zp[4]:13 2000002.0
|
||||
(dword) ultoa_append::sub
|
||||
(dword) ultoa_append::sub#0 sub zp[4]:19 3.3335000005E9
|
||||
(dword) ultoa_append::value
|
||||
(dword) ultoa_append::value#0 value zp[4]:13 3666667.333333333
|
||||
(dword) ultoa_append::value#1 value zp[4]:13 2.0000000002E10
|
||||
(dword) ultoa_append::value#2 value zp[4]:13 5.001833334166666E9
|
||||
|
||||
zp[4]:2 [ main::i#2 main::i#1 ]
|
||||
zp[2]:6 [ print_char_cursor#14 print_line_cursor#1 ]
|
||||
zp[2]:8 [ print_line_cursor#9 print_line_cursor#15 print_line_cursor#25 print_line_cursor#24 ]
|
||||
zp[2]:10 [ print_char_cursor#17 print_char_cursor#40 print_char_cursor#23 ]
|
||||
zp[1]:12 [ ultoa::digit#2 ultoa::digit#1 ]
|
||||
zp[4]:13 [ ultoa::value#2 ultoa::value#6 ultoa::value#1 ultoa::value#0 ultoa_append::value#2 ultoa_append::value#0 ultoa_append::value#1 print_ulong_decimal::w#0 ultoa_append::return#0 main::$11 main::$9 main::$10 main::$5 main::$6 main::$7 main::$8 ]
|
||||
reg byte x [ ultoa::started#2 ultoa::started#4 ]
|
||||
reg byte x [ ultoa_append::digit#2 ultoa_append::digit#1 ]
|
||||
zp[2]:17 [ memset::dst#2 memset::dst#1 ultoa::buffer#11 ultoa::buffer#14 ultoa::buffer#4 ultoa::buffer#3 ultoa_append::buffer#0 print_str::str#2 print_str::str#0 ]
|
||||
reg byte a [ print_char::ch#0 ]
|
||||
reg byte a [ ultoa::$4 ]
|
||||
reg byte a [ ultoa::$11 ]
|
||||
zp[4]:19 [ ultoa::digit_value#0 ultoa_append::sub#0 ]
|
||||
Loading…
Reference in New Issue
Block a user