flat assembler
Message board for the users of flat assembler.
 Home   FAQ   Search   Register 
 Profile   Log in to check your private messages   Log in 
flat assembler > Examples and Tutorials > BASELIB: General purpose libs for beginners

Goto page Previous  1, 2, 3, 4, 5, 6, 7  Next
Author
Thread Post new topic Reply to topic
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
@Revo

Noted.
Post 02 Jun 2015, 20:36
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
I added 2 more library for 32-bit version (win and linux). I 'adopted' them straight from the 64-bit versions, so could be buggy somewhere.

Plus, I updated the fnotes into PDF format because I didn't expect DOS and Linux text presentation to differ that much.

Due to its low-levelness, these routines are highly usable in NASM, except that floating point part. (You need to convert them to hex first. Use prthex routine to get their Hex equivalences). Example;

mov rax,10.0 is changed to mov rax,0x4024000000000000

Example using prthexu routine (unsigned) to get a FP equivalence;


Code:
mov rax,1.0
call prthexu       ;Display and equals to 0x3FF0000000000000
mov eax,10.0
call prthexu       ;Display and equals to 0x41200000



Replace all those FP immediates with their Hex equivalences. Better still, why not use FASM instead.

Good luck and may the force be with you Very Happy


Last edited by fasmnewbie on 06 Jul 2015, 14:14; edited 1 time in total
Post 02 Jun 2015, 20:52
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
prtdbl is a 64-bit precision string conversion of raw FP data. It offers no precision or rounding control. Some motivated beginners may attempt their own precision or rounding policy over a FP data. Below is a routine that can offer more control to precision and rounding by splitting a double precision data to integral and precision part to make it easier to do just that.


Code:
;------------------------------
;##     @dblsplit(1)/2
;       Split a double into two parts
;       Return integral in RAX
;       Return fraction in RBX
;------------------------------
dblsplit:
        push    rdx
        sub     rsp,140          ;local data space
        mov     [rsp],rax        ;copy
        mov     [rsp+8],rax
        lea     rdx,[rsp+16]     ;Save FPU
        fsave   [rdx]            ;
        mov     rbx,rax
        xor     rdx,rdx          ;Negative marker
        finit                    ;Clear FPU
        fstcw   [rsp+138]        ;
        bts     word[rsp+138],10 ;Round down
        fldcw   [rsp+138]        ;
        fld     qword[rsp]       ;Load value
        fabs                     ;Absolute it
        test    rax,rax          ;If negative,
        jns     .nope
        mov     rdx,1            ;Marker up
.nope:
        fld     qword[rsp+8]     ;load the same value
        fabs
        fistp   qword[rsp+8]     ;turn it to integer
        fild    qword[rsp+8]     ;Re-load it
        fsub    st1,st0          ;Substract true vs integral
        fstp    qword[rsp]       ;Save to integral
        fabs
        fstp    qword[rsp+8]     ;Remainder as fraction
        mov     rax,[rsp]        ;integral part
        mov     rbx,[rsp+8]      ;fraction part
        cmp     rdx,1
        jne     .done
        bts     rax,63           ;Negate it if negative
.done:
        lea     rdx,[rsp+16]     ;Restore FPU
        frstor  [rdx]
        add     rsp,140          ;Restore stack
        pop     rdx              ;
        ret



This routine will return the integral part in RAX and the fraction part in RBX. Beginners can start working on each different part separately and combine the result to form a FP representation with more customized precision and rounding control.

Please note that this works only normal FP data.

Sample usage:

Code:
mov rax,-45.3234
call dblsplit
;now RAX contains -45.00
;RBX contains 0.3234



Hope this would be useful.

p/s This is not part of the attached routines. You can add this routine to the current one without any problem (to Linux and Win version).

Happy coding.
Post 08 Jun 2015, 08:05
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
I updated the library (June 13th, 2015). Deleted some, added some other routines. Please test the prtxmm/dumpxmm routine because my knowledge of SSE instructions is quite limited at the moment. prtxmm/dumpxmm now supports byte-level integer instructions (hopefully). Thanks and be cool.
Post 13 Jun 2015, 14:33
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
June 16th,2015

I updated the flib today for my midnite coding routine. Nothing fancy. Just introduced another routine and patching up here and there. I think this is the final revision for flib.
Post 15 Jun 2015, 18:18
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
June 18th. New lib uploaded

I uploaded FCORE.zip as the replacement for FLIB. I introduced "sleep" function in this release. Also added "prtdble", a prtdbl extension that takes decimal places as the 2nd argument in RBX.

I think this library is complete now and has almost every routines required by beginners to start learning assembly programming quite comfortably.

Enjoy your coding.
Post 18 Jun 2015, 11:54
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
A little correction to function "sleep" for Linux version. Just a line of code;


Code:
;--------------------------------
;#42    : sleep(1)
;OBJ    : Put execution at sleep
;--------------------------------
;RAX    : Milliseconds (unsigned)
;               > reg64,imm,[dq]
;--------------------------------
;NOTE   : 1000ms = 1s.
;RETN   : -
;--------------------------------
sleep:
        push    r11
        push    rdi
        push    rsi
        push    rax
        push    rcx
        push    rdx
        mov     rdi,1000000     ;convert to nano
        mul     rdi
        cmp     rax,1000000000  ;if > 1s
        jae     .over                   
        push    rax                             
        push    0                               
        jmp     .ok
.over:
        xor     rdx,rdx
        mov     rcx,1000000000 ;<---- change to this one
        div     rcx
        and     rdx,0xffff
        push    rdx             ;nano
        push    rax             ;sec
.ok:    
        lea     rsi,[rsp+8]     ;nano
        lea     rdi,[rsp]       ;sec
        mov     rax,35
        syscall
        add     rsp,16
        pop     rdx
        pop     rcx
        pop     rax
        pop     rsi
        pop     rdi
        pop     r11
        ret



Sorry for the inconvenience.
Post 19 Jun 2015, 03:52
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
I added prtregd (display register in decimal) and str2flt. Also included alternatives to getdbl, getflt and getint routines. I think those are the last additions to the current library and I am not maintaining the library anymore. Hope those are enough for beginners. Enjoy it and happy coding.
Post 20 Jun 2015, 12:46
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
This morning I realized that this library is missing one extremely important component - the ability to view the content of the stack as the code progresses. So I updated the main zip (FCORE.zip) to include this important piece of routine which is a must-have. The routine is stackview and stackviewd to display its content in decimal. One Linux example (Windows version should behave the same);


Code:
format ELF64 executable 3

mov rax,4       ;Start with 'empty' stack. traverse 4 items
call stackview  ;view stack
call newline
push 35h        ;push one item
mov rax,4       ;traverse 4 items
call stackview  ;view stack
call newline
push 34h        ;push another item
mov rax,4       ;traverse 4 items
call stackview  ;view stack
call newline
pop rcx         ;Pop one item
mov rax,4       ;view 4 items at once
call stackview  ;Display reduced stack. 
call newline
mov rax,rcx     ;confirm RCX contains the last item popped
call prthex

call exit



With the following output (stack grows downwards). The (*) is the TOS and the value in [..] is the stack address.


Code:
[00007FFF32C5EB6800007FFF32C6097E
[00007FFF32C5EB600000000000000000
[00007FFF32C5EB5800007FFF32C60975
[00007FFF32C5EB500000000000000001*

[00007FFF32C5EB600000000000000000
[00007FFF32C5EB5800007FFF32C60975
[00007FFF32C5EB500000000000000001
[00007FFF32C5EB480000000000000035*

[00007FFF32C5EB5800007FFF32C60975
[00007FFF32C5EB500000000000000001
[00007FFF32C5EB480000000000000035
[00007FFF32C5EB400000000000000034*

[00007FFF32C5EB600000000000000000
[00007FFF32C5EB5800007FFF32C60975
[00007FFF32C5EB500000000000000001
[00007FFF32C5EB480000000000000035*

34



Sorry for the late addition. I didn't realize it until today. This offers a slight advantage over the the debugger because beginners can see the effect immediately as the coding progresses.
Post 26 Jun 2015, 09:41
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
People might ask why I am creating this library...

The answer is simple: I'd love to see FASM gains much more acceptance in learning institutions. By having a simple library like this, decision makers would be encouraged to adopt FASM as their main assembler for related courses in their institutions. And MASM or NASM-infested instructors now can easily compare codes and understand / appreciate FASM much easier for adoption.

I know the chance is slim due to lack of FASM-speaking reference materials. But with this very small small step, who knows what lies ahead. There are fence-sitters out there who still can't decide which assembler to use.

But my code is in poor condition. Hope others can help to make it better and and on par with other similar library (in other ASM language) which I found are far more advanced.

So I hope I did not harm to FASM as a whole with this small small effort.

Until next time.
Post 29 Jun 2015, 22:38
View user's profile Send private message Visit poster's website Reply with quote
redsock



Joined: 09 Oct 2009
Posts: 261
Location: Australia
I had/have similar hopes with my own x86_64 library (https://2ton.com.au/HeavyThing/) and since I GPLv3'd it early this year, I must say there are far fewer people interested in "assembler made easy" than I originally thought there were.

I like your library's simplicity of covering the bases and wish you luck toward your goal in any case

Cheers Smile
Post 30 Jun 2015, 07:05
View user's profile Send private message Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
I added 2 more routines (fpdinfo, fpfinfo) to enable beginners to analyze floating point binary for double and float.

I updated the Documentation to enable beginners to use Section and Segment instead of the default flat model.

I modified stackview/d/u so that the address is shown on the right side of the data. This makes more sense in terms of bytes addressing and offset, for example, [rbp-1] would be confusing if I placed the address on the left (Most Significant) side.

I tested the code quite thoroughly and found no more fatal / non-fatal bugs. If you found one, you can write it here and I'll see what I can do.

Until a bug is found, this is the final version of FCORE.

Good luck.
Post 04 Jul 2015, 04:36
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
Fixed a minor bug in fpfinfo.
Post 08 Jul 2015, 17:53
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
There's a thread by Picnic if beginners wish to extend their knowledge on console-based graphics and other cool stuff.

http://board.flatassembler.net/topic.php?t=15394
Post 01 Aug 2015, 03:14
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
I uploaded a slightly improved versions with some minor additions of routines that I think are necessary for beginners. In addition, I also included the 32-bit versions of the library just in case someone need it. The 32-bit versions are direct adoption from its 64-bit siblings.

Some of the new routines introduced;

1. mulf, addf, subf, divf
Considering the facts that beginners often mistakenly use ADD, MUL, SUB and DIV for floating point use instead of integers. These would softly introduce them to floating point operations before even actually learning about SSE and FPU.

2. sse_round and fpu_round
Allow users to set the rounding mode of SSE and FPU.

3. factorial, log10 and ln10

I think that's it for now. The zip file is EASY64.zip found at the first post.

Enjoy.
Post 22 Sep 2015, 09:14
View user's profile Send private message Visit poster's website Reply with quote
TmX



Joined: 02 Mar 2006
Posts: 783
Location: Jakarta, Indonesia
Thanks fasmnewbie.
Gotta learn this stuff on weekend Smile
Post 22 Sep 2015, 09:57
View user's profile Send private message Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
I missed the dblsplit update due to some mixed up in source files. The old one isn't wrong but this is more compact and shorter. It's applicable to both 64-bit versions.


Code:
;------------------------------------
;dblsplit(1)/2
;Split a double into parts
;------------------------------------
;RAX    : The FP value to split
;------------------------------------
;Ret    : Integral part in RAX
;       : Fraction part in RBX
;Note   : Value in should in FP format
;       : Deals normal FP value only
;------------------------------------
dblsplit:
        push    rbp
        mov     rbp,rsp
        sub     rsp,512
        and     rsp,-16
        fxsave  [rsp]
        call    fpu_round.zero
        push    rax
        fld     qword[rsp]
        fld     qword[rsp]
        frndint
        fsub    st1,st0
        fstp    qword[rsp]
        mov     rax,[rsp]
        fabs
        fstp    qword[rsp]
        pop     rbx
        fxrstor [rsp]
        mov     rsp,rbp
        pop     rbp
        ret



Last edited by fasmnewbie on 24 Sep 2015, 12:35; edited 1 time in total
Post 23 Sep 2015, 15:15
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399

TmX wrote:
Thanks fasmnewbie.
Gotta learn this stuff on weekend Smile

You, learning from my codes? I don't buy it. Not a chance. Lu pura2 jadi newbie je tu bro. ;D
Post 23 Sep 2015, 15:19
View user's profile Send private message Visit poster's website Reply with quote
fasmnewbie



Joined: 01 Mar 2011
Posts: 399
I updated the zip file to reflect a recent addition of fpu_tag so that a user can quickly verify an FPU register's status quickly. This is actually an information from the FPU's Tag word register.

Example;


Code:
format PE64 console
include 'win64axp.inc'

finit           ;Init FPU
call fpu_tag   ;View default Tag status
fldpi          ;Load PI
fldz           ;Load a zero
call fpu_tag  ;See the status of the Tag word
call exitp 



Will produce this output


Code:
T7 T6 T5 T4 T3 T2 T1 T0
11 11 11 11 11 11 11 11=FFFF
T7 T6 T5 T4 T3 T2 T1 T0
00 01 11 11 11 11 11 11=1FFF



I think that's the final addition of routine to the library. I can't think of any other basic routine that can further help beginners going through those 'difficult' phases in learning assembly programming. I think 110 routines for 64-bit version and 109 for 32-bit versions are more than enough. IMO, this is the most complete native assembly library routine one can find from the internet, although not the best.

Anyway, good luck and happy coding.
Post 25 Sep 2015, 19:34
View user's profile Send private message Visit poster's website Reply with quote
JohnFound



Joined: 16 Jun 2003
Posts: 3434
Location: Bulgaria

fasmnewbie wrote:
I updated the zip file to reflect a recent addition of...



Isn't it better to adopt some version control system. This way all changes will be easily followed and the history will be saved as well.

I would suggest using Fossil scm, because it has the same minimalistic spirit as assembly programming itself.

You can host your repositories free at Chisel or on your own hosting (with fossil it is very easy).

_________________
Tox ID: A48DEF727DF44C3B5C2E576B65021F1A45D8FA52E2F8E257F1CAE148BBADB162FDF7820BD1F9
Post 25 Sep 2015, 20:47
View user's profile Send private message Visit poster's website ICQ Number Reply with quote
Display posts from previous:
Post new topic Reply to topic

Jump to:  
Goto page Previous  1, 2, 3, 4, 5, 6, 7  Next

< Last Thread | Next Thread >

Forum Rules:
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
You cannot attach files in this forum
You can download files in this forum


Powered by phpBB © 2001-2005 phpBB Group.

Main index   Download   Documentation   Examples   Message board
Copyright © 2004-2016, Tomasz Grysztar.