Lets translate all of the latest Slackware 64 bits stable version source code to Assembler. I'll join the project on July 1st...

Slax-Dude · 05-26-2022, 06:40 AM

OK, OK.. I'l go first, since none seems to want to do it: There is no project. This is a troll.

exhibit A: a serious project this size would have some kind of website for coordination of this HUGE effort
exhibit B: any knowledgeable developer/programmer with enough skill to do it would understand that the effort would seriously outweigh any potential benefits
exhibit C: any serious project of this nature would not start with a distro (slackware or any other) and just go after the kernel first
exhibit D: NO... just no...

brianL · 05-26-2022, 06:55 AM

Quote:

Originally Posted by Slax-Dude

OK, OK.. I'l go first, since none seems to want to do it: There is no project. This is a troll.

OP possibly a troll...? I'd never have guessed...

amikoyan · 05-26-2022, 07:03 AM

The title from the OP is a give away:

Quote:

Lets translate all of the latest Slackware 64 bits stable version source code to Assembler. I'll join the project on July 1st...

As in "Lets <insert dumb suggestion here>. You all make a start while I watch. I'll join the project after several weeks of watching you all do it..."

April 1st was some time ago!

nobodino · 05-26-2022, 08:37 AM

that's the reason why I asked for some proof: github or gitlab project.
Anything else is ?

Petri Kaukasoina · 05-26-2022, 09:34 AM

Quote:

Originally Posted by brianL

He wants to translate the entire Slackware source code from whatever language into assembly language.

The hard stuff is to transform all the code written in interpreted languages to assembly language.

But it's easy for c code and other compiled languages, as that's what the compiler does. If you watch your tmp directory while compiling stuff you can see .s files appearing and disappearing. They contain the compiled code in assembly language. If you add '-S' to the gcc command, it stops after compilation, does not assemble, leaving the .s assembly code for you to study.

LuckyCyborg · 05-26-2022, 10:08 AM

Quote:

Originally Posted by Petri Kaukasoina

The hard stuff is to transform all the code written in interpreted languages to assembly language.

But it's easy for c code and other compiled languages, as that's what the compiler does. If you watch your tmp directory while compiling stuff you can see .s files appearing and disappearing. They contain the compiled code in assembly language. If you add '-S' to the gcc command, it stops after compilation, does not assemble, leaving the .s assembly code for you to study.

Reusing the machine generated assembler files probably will be widely useless, because the result of compilation will be barely different as speed or size.

And excuse my ignorance, but I believed that rewriting a program (or an entire Linux ecosystem) means analyzing its original source code, i.e. the C/C++ files, then the programmer to write by hand a new application in Pascal or Assembler or whatever, which program behaves identically with the original one.

This would mean that the programmer doing this have an excellent knowledge of the original programming language and the associated APIs and ABIs, and also of the target programming language and the associated APIs and ABIs.

And let's do not forget the bugs - at this amount of source code written, probably there will be trillions of specific bugs. Who will fix them?

I for one, I sincerely believe that the OP has no idea how big and complex is the proposed target. As well, he could have said "let's build a superlight speed engine" ...

Anyway, the idea of an operating system written entirely in Assembler is nothing new. For example, there is MenuetOS:

http://menuetos.net/

Wonder yourself: if the MenuetOS is so fast (yet, it's) then WHY it's not mainstream instead of Linux or BSD? And if it's that simple to write operating systems in assembler, why MenuetOS is still rudimentary after 12 years of development? WHy it does not have millions of users?

And while not open source (yet?) let's do not forget that MS-DOS (all versions) and Windows 1.0 was entirely written in assembler.

LuckyCyborg · 05-26-2022, 10:18 AM

BTW, there is a simple audio player for MenuetOS

Code:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;   64 bit Menuet audio example
;
;   Compile with FASM 1.60 or above
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

use64
                                    
    org   0x0

    db    'MENUET64'              ; Header identifier
    dq    0x01                    ; Version
    dq    START                   ; Start of code
    dq    image_end               ; Size of image
    dq    0x600000                ; Memory for app
    dq    0x0ffff0                ; Rsp
    dq    0x00                    ; Prm 
    dq    0x00                    ; Icon

; All drivers support playback and record with 48khz,16bit,stereo,16kB/buff
;
; Latency: 85.33msec @  48 khz, 16-bit stereo, 16384 bytes/buffer
;           0.67msec @  48 khz, 16-bit stereo,   128 bytes/buffer
;           0.08msec @ 192 khz, 24-bit stereo,    96 bytes/buffer

wavelocation   equ 0x100000
wavelocation24 equ 0x200000

START:

    mov   rax , 141         ; Enable system font
    mov   rbx , 1
    mov   rcx , 1
    mov   rdx , 5 shl 32 + 5
    mov   r8  , 9 shl 32 + 12
    int   0x60

    mov   rax , 117         ; Audio card available?
    mov   rbx , 1
    int   0x60
    cmp   rax , 0
    jne   noavail
    mov   [available],byte 1
  noavail:

    call  draw_window       ; At first, draw the window

    call  calculate_audiowave

still:

    mov   rax , 23          ; Wait here for event
    mov   rbx , 1
    int   0x60

    test  rax , 0x1         ; Window redraw
    jnz   window_event
    test  rax , 0x2         ; Keyboard press
    jnz   key_event
    test  rax , 0x4         ; Button press
    jnz   button_event

    call  check_mouse       ; Check mouse

    jmp   still


window_event:

    call  draw_window
    jmp   still         


key_event:

    mov   rax , 0x2        ; Read the key and ignore
    int   0x60
    jmp   still        


playaudio:

    ; Device available

    cmp   [available],dword 1
    je    device_available
    mov   rax , 4
    mov   rbx , unsupported
    mov   rcx , 48
    mov   rdx , 123
    mov   r9  , 1
    mov   rsi , 0x000000
    int   0x60
    mov   rax , 23
    mov   rbx , 125
    int   0x60
    mov   rax , 4
    mov   rbx , unsupported
    mov   rcx , 48
    mov   rdx , 123
    mov   r9  , 1
    mov   rsi , 0xffffff
    int   0x60
    ret
  device_available:

    ; Default setup 0 supported by all drivers
    ; (48000hz,16bit/ch,stereo,signed,16384bytes/buff)

    mov   rax , 4
    mov   rbx , playing
    mov   rcx , 72
    mov   rdx , 123
    mov   r9  , 1
    mov   rsi , 0x000000
    int   0x60

    ; Clear buffers

    mov   rdi , 0x180000
    mov   rcx , 65536
    mov   rax , 0
    cld
    rep   stosb
    mov   rax , 117
    mov   rbx , 2
    mov   rcx , 0x180000
    mov   rdx , 0
    int   0x60
    mov   rax , 117
    mov   rbx , 2
    mov   rcx , 0x180000
    mov   rdx , 1
    int   0x60

    ; Start playback

    mov   r14 , 0              ; current playbuffer
    mov   r15 , [wavestart]    ; 16bit/24bit wave

    ; Play command

    mov   rax , 117
    mov   rbx , 3
    int   0x60

  waitmore:

    ; Get current playbuffer (0/1)

    mov   rax , 117
    mov   rbx , 4
    int   0x60

    cmp   rbx , r14
    jne   nowantedblock

    ; Give data for nonactive playbuffer (0/1)

    mov   rax , 117
    mov   rbx , 2
    mov   rcx , r15 ; wave position
    mov   rdx , r14 ; playbuffer  
    add   rdx , 1
    and   rdx , 1
    int   0x60

    add   r15 , [buffersize]
    add   r14 , 1
    and   r14 , 1

  nowantedblock:

    cmp   r15 , [waveend]
    ja    audiodone

    cmp   [buffertime],dword 1000 ; below ms buffer
    jb    nodelay
    mov   rax , 105
    mov   rbx , 1
    int   0x60
  nodelay:

    mov   rax , 11
    int   0x60
    cmp   rax , 0
    je    waitmore

  audiodone:

    ; Stop playing at button press

    mov   rax , 117
    mov   rbx , 5
    int   0x60

    ; Clear playing text

    mov   rax , 4
    mov   rbx , playing
    mov   rcx , 72
    mov   rdx , 123
    mov   r9  , 1
    mov   rsi , 0xffffff
    int   0x60

    ret


calculate_audiowave:

    ; Get sine to memory

    mov   rcx , 0
  newsine:
    mov   rax , 122
    mov   rbx , 6
    int   0x60
    mov   [sine+rcx*8],rbx
    add   rcx , 1
    cmp   rcx , 3600
    jb    newsine

    ; Calculate example audiowave

    mov   r14 , 0            ; frequency location
    mov   r15 , wavelocation ; wave location
  newwave:
    mov   rcx , 0
    mov   rdi , 0
  setwave:
    push  rcx
    shr   rcx , 16
    mov   rbx , [sine+rcx*8]
    pop   rcx
    shr   rbx , 2
    mov   [r15+rdi+0],bx
    mov   [r15+rdi+2],bx
    mov   rdx , ((3600*65536)/(16384/4))
    movzx rax , byte [freq+r14]
    imul  rdx , rax
    add   rcx , rdx
    add   rdi , 4
    cmp   rcx , 3600*65536
    jb    norcx
    sub   rcx , 3600*65536
  norcx:
    cmp   rdi , 16384*2
    jb    setwave
    add   r15 , 16384*2
    add   r14 , 1
    cmp   r14 , 11
    jbe   newwave

    ; 16bit -> 24bit

    mov   rsi , wavelocation
    mov   rdi , wavelocation24
  new32:
    xor   rax , rax
    mov   ax , [rsi]
    shl   rax , 8
    mov   [rdi],eax
    mov   [rdi+3],eax
    mov   [rdi+6],eax
    mov   [rdi+9],eax
    add   rsi , 2
    add   rdi , 12
    cmp   rsi , wavelocation + 16384*11*2
    jb    new32

    ret



check_mouse: ; Select audioformat from list

    mov   rax , 37
    mov   rbx , 2
    int   0x60
    cmp   rax , 0
    je    nomousedown

    mov   rax , 37
    mov   rbx , 1
    int   0x60
    mov   rbx , rax
    shr   rax , 32

    cmp   rax , 22
    jb    nomousedown
    cmp   rax , 155
    ja    nomousedown
    and   rbx , 0xffff
    sub   rbx , 109-42
    mov   rax , rbx
    mov   rbx , 12
    xor   rdx , rdx
    div   rbx
    cmp   rax , 4
    jae   nomousedown
    add   rax , [vscroll_value]
    sub   rax , 300
    cmp   rax , [formats]
    jae   nomousedown

    mov   [selected],rax
    call  draw_audio_info
    call  set_audio_parameters

  waitmouseup:
    mov   rax , 5
    mov   rbx , 1
    int   0x60
    mov   rax , 37
    mov   rbx , 2
    int   0x60
    cmp   rax , 0
    jne   waitmouseup

  nomousedown:

    ret


set_audio_parameters:

    ; Get buffersize for selected setup
    mov   rax , 117
    mov   rbx , 7
    mov   rcx , [selected]
    int   0x60
    mov   rax , rbx
    shr   rax , 32+16
    mov   [buffersize],rax

    ; Calculate buffer time duration in microseconds
    mov   r8  , rbx
    and   r8  , 0xfffff ; freq
    mov   r9  , rbx
    shr   r9  , 32
    and   r9  , 0xff    ; channels
    mov   r10 , rbx
    shr   r10 , 24
    and   r10 , 0xff    ; bytes / sample
    shr   r10 , 3
    imul  r8  , r9
    imul  r8  , r10
    imul  r8  , 10
    mov   rax , [buffersize]
    imul  rax , 100000000
    xor   rdx , rdx
    mov   rbx , r8
    div   rbx
    add   rax , 5 ; roundup
    xor   rdx , rdx
    mov   rbx , 10
    div   rbx
    mov   [buffertime],rax

    ; Use 16bit/24bit wave for playback
    mov   [wavestart],dword wavelocation
    mov   [waveend],dword wavelocation+20*16384*1
    cmp   r10 , 2
    je    wave16bit
    mov   [wavestart],dword wavelocation24
    mov   [waveend],dword wavelocation24+20*16384*8
  wave16bit:

    ; And select setup at card
    mov   rax , 117
    mov   rbx , 8
    mov   rcx , [selected]
    int   0x60

    ret



button_event:

    mov   rax , 0x11
    int   0x60

    ; rax = status
    ; rbx = button id

    cmp   rbx , 1            ; Play audio
    jne   no_play
    call  playaudio
    jmp   still
  no_play:

    cmp   rbx , 300          ; Vertical scroll
    jb    no_vertical_scroll
    cmp   rbx , 399
    ja    no_vertical_scroll
    mov   [vscroll_value], rbx
    call  draw_audio_info
    jmp   still
  no_vertical_scroll:

    cmp   rbx , 0x10000001   ; Close button
    je    terminate
    cmp   rbx , 0x104        ; Close menu selection
    je    terminate
    jmp   noterm
  terminate:
    mov   rax , 512
    int   0x60
  noterm:

    jmp   still



draw_window:

    mov   rax , 0xC                          ; Beginning of window draw
    mov   rbx , 0x1
    int   0x60

    mov   rax , 0x0                          ; Draw window
    mov   rbx , 0x0000010000000000 + 193     ; x start & size
    mov   rcx , 0x0000008000000000 + 180     ; y start & size
    mov   rdx , 0x0000000000FFFFFF           ; type    & border color  
    mov   r8  , 0x0000000000000001           ; draw flags
    mov   r9  , window_label                 ; 0 or label - asciiz
    mov   r10 , menu_struct                  ; 0 or pointer to menu struct
    int   0x60

    mov   rax , 8
    mov   rbx , 20 * 0x100000000 + 70
    mov   rcx , 135* 0x100000000 + 20
    mov   rdx , 1
    mov   r8  , 0
    mov   r9  , button1
    int   0x60

    mov   rax , 8
    mov   rbx , 100* 0x100000000 + 70
    mov   rcx , 135* 0x100000000 + 20
    mov   rdx , 2
    mov   r8  , 0
    mov   r9  , button2
    int   0x60

    call  draw_audio_info

    mov   rax , 0xC
    mov   rbx , 0x2
    int   0x60

    ret



draw_audio_info: ; Display audio-format list

    mov   rax , 38
    mov   rbx , 21
    mov   rcx , 109-42
    mov   rdx , 169
    mov   r8  , 161-42
    mov   r9  , 0xa0a0a0
    push  r8
    mov   r8  , rcx
    int   0x60
    pop   r8
    push  rcx
    mov   rcx , r8
    int   0x60
    pop   rcx
    push  rdx
    mov   rdx , rbx
    int   0x60
    pop   rdx
    add   rbx , 1
    add   rcx , 1
    sub   rdx , rbx
    sub   r8  , rcx
    shl   rbx , 32
    add   rbx , rdx
    sub   rbx , 13
    shl   rcx , 32
    add   rcx , r8
    mov   rax , 13
    mov   rdx , 0xffffff
    int   0x60

    mov   rax , 4
    mov   rbx , string_info
    mov   rcx , 23
    mov   rdx , 93-42
    mov   r9  , 1
    mov   rsi , 0x000000
    int   0x60

    mov   r15 , [vscroll_value]
    sub   r15 , 300
    mov   rax , 117
    mov   rbx , 7
    mov   rcx , r15
    int   0x60
    cmp   rax , 0
    jne   done

    mov   r13 , 0

    mov   [formats],r15

  newsetup:
    ;
    mov   rax , 117
    mov   rbx , 7
    mov   rcx , r15
    int   0x60
    cmp   rax , 0
    jne   done
    ;
    add   [formats],dword 1
    ;
    cmp   r13 , 4
    jae   nodisplay
    ;
    mov   [curx],dword 0
    mov   rax , rbx
    and   rax , 0xffffff
    call  addtext
    mov   rax , rbx
    shr   rax , 24
    and   rax , 0xff
    call  addtext
    mov   rax , rbx
    shr   rax , 32
    and   rax , 0xff
    call  addtext
    ;mov   rax , rbx
    ;shr   rax , 40
    ;and   rax , 0xf
    ;call  addtext
    mov   rax , rbx
    shr   rax , 44
    and   rax , 0x1f
    mov   cl  , al
    mov   rax , 10b
    shl   rax , cl
    call  addtext
    mov   rax , rbx
    shr   rax , 48
    call  addtext
    mov   rax , [curx]
    mov   [text+rax-1],byte 0
    ;
    mov   rax , 13
    mov   rbx , 24 shl 32 + 6*22
    mov   rcx , r13
    imul  rcx , 12
    add   rcx , 110-42
    shl   rcx , 32
    add   rcx , 12
    mov   rdx , 0xd0d0d0
    mov   r10 , r13
    add   r10 , [vscroll_value]
    sub   r10 , 300
    cmp   r10 , [selected]
    je    yessel
    mov   rdx , 0xffffff
  yessel:
    int   0x60
    mov   rax , 4
    mov   rbx , text
    mov   rcx , 25
    mov   rdx , r13
    imul  rdx , 12
    add   rdx , 112-42
    mov   r9  , 1
    mov   rsi , 0x000000
    int   0x60
    ;
  nodisplay:
    ;
    add   r15 , 1
    add   r13 , 1
    ;
    jmp   newsetup

  done:

    call  draw_vertical_scroll

    ret


addtext: ; Add parameters to audioformat line

    push  rbx

    mov   rdi , number+10
  newaddt:
    mov   rbx , 10
    xor   rdx , rdx
    div   rbx
    add   dl , 48
    mov   [rdi],dl
    sub   rdi , 1
    cmp   rax , 0
    jne   newaddt
    mov   rcx , number+10
    sub   rcx , rdi
    mov   rsi , rdi
    add   rsi , 1
    mov   rdi , [curx]
    add   rdi , text
    add   [curx],rcx
    cld
    rep   movsb

    mov   rax , [curx]
    mov   [text+rax],byte ','
    add   [curx],dword 1

    pop   rbx

    ret


draw_vertical_scroll:

    ; Vertical scroll

    mov   rax , 113
    mov   rbx , 1
    mov   rcx , 300
    mov   rdx , [formats]
    mov   r8  , [vscroll_value]
    mov   r9  , 157
    mov   r10 , 110-42
    mov   r11 , 50
    int   0x60

    ret


;
; Data area
;

window_label: db  'AUDIO EXAMPLE',0
button1:      db  'PLAY',0                          
button2:      db  'STOP',0
unsupported:  db  'Card unavailable.',0
playing:      db  'Playing..',0

cardhz:     dq  0x0
multiplier: dq  0x0
blockwait:  dq  0x0
available:  dq  0x0
buffertime: dq  0x0

wavestart:  dq wavelocation
waveend:    dq wavelocation+20*16384*1

freq:  db 27,30,34,36,40,45,51,54,54,54,54,54,54,54

text:    db  '                                    ',0
number:  db  '                                    ',0

curx:    dq  0x0
formats: dq  0x0

buffersize: dq 16384  ; for default setup 0
selected:   dq 0x0    ; selected setup

string_info: db 'Formats:',0 ; hz,bits,chs,bufs,bufsize

vscroll_value: dq 300

menu_struct:               ; Menu Struct

    dq   0                 ; Version
    dq   0x100             ; Start value of ID to return ( ID + Line )
                           ; Returned when menu closes and
                           ; user made no selections.
    db   0,'FILE',0        ; ID = 0x100 + 1
    db   1,'Open..',0
    db   1,'-',0
    db   1,'Quit',0        ; ID = 0x100 + 2
    db   255               ; End of Menu Struct

sine: times 3600 dq ?

image_end:

Yeah, this is not Bash scripting, people!

pghvlaans · 05-26-2022, 10:28 AM

Quote:

Originally Posted by LuckyCyborg

http://menuetos.net/

Seems like a pretty impressive project, for what it is. It even purports to do SMP, which already puts it way ahead of GNU Hurd

Petri Kaukasoina · 05-26-2022, 10:29 AM

Quote:

Originally Posted by LuckyCyborg

Reusing the machine generated assembler files probably will be widely useless, because result of compilation will be barely different as speed of size.

The executable code would be exactly the same, of course. But it would fullfill the OP's request to "translate all of the latest release of Slackware 64 sourcecode to Assembler", I guess.

Quote:

I believed that rewriting a program (or an entire Linux ecosystem) means analyzing its original source code, i.e. the C/C++ files, then the programmer to write by hand a new application in Pascal or Assembler or whatever, which program behaves identically with the original one.

He could start by creating a version of the Linux kernel first, hand written in assembly language.

LuckyCyborg · 05-26-2022, 10:42 AM

Quote:

Originally Posted by pghvlaans

Seems like a pretty impressive project, for what it is. It even purports to do SMP, which already puts it way ahead of GNU Hurd

If you like the MenuetOS, there's also KolibriOS. It have even support for Ext4FS (ro).

http://kolibrios.org/en/

Like I said, the OP does not invented the wheel - however, we should note that nobody else was that nuts to propose the forking of the entire Linux ecosystem.

half-word · 05-26-2022, 11:33 AM

Ok let's think in programmer years. Just Linux kernel already has tens of thousands of programmer years.

That means that to (re)write it, roughly one programmer would need to work tens of thousands of years. Or a team of tens of programmers would need a thousand years. Or a team of thousand programmers would work for decades. And so on.

That's just the kernel, imagine how many more lines of code the userland contains. The idea is completely bonkers.

Quote:

Originally Posted by Jeebizz

I'd like them more, if they removed that stupid trackpad nipple in the middle of the keyboard, there is no point to it imo.

Without that little wonder, I'd stop using ThinkPads.

amikoyan · 05-26-2022, 02:27 PM

Quote:

Originally Posted by half-word

Without that little wonder, I'd stop using ThinkPads.

I find it zooms around way too fast for me to use it properly. I am sure there is a setting to slow it down, but is it worth investigating?

Jeebizz · 05-26-2022, 04:00 PM

Quote:

Originally Posted by half-word

Ok let's think in programmer years. Just Linux kernel already has tens of thousands of programmer years.

That means that to (re)write it, roughly one programmer would need to work tens of thousands of years. Or a team of tens of programmers would need a thousand years. Or a team of thousand programmers would work for decades. And so on.

That's just the kernel, imagine how many more lines of code the userland contains. The idea is completely bonkers.

Without that little wonder, I'd stop using ThinkPads.

To each their own, but it always got in the way when typing and just is a nuisance.

Quote:

Originally Posted by amikoyan

I find it zooms around way too fast for me to use it properly. I am sure there is a setting to slow it down, but is it worth investigating?

This! Either it was too fast/sensitive , or then suddenly too slow and a pain to get to a window - for me it is worse than the touchpad, and least with that I can navigate somewhat better, if I don't have a mouse on hand. That orange thing is just fscking useless imo.

rkelsen · 05-26-2022, 06:37 PM

Quote:

Originally Posted by LuckyCyborg

And while not open source (yet?) let's do not forget that MS-DOS (all versions) and Windows 1.0 was entirely written in assembler.

MS-DOS 5.0 was a bit over 2Mb (mega bytes) in size, and took the team at Microsoft almost a full 3 years to develop.

Windows 1.0 was less than 1Mb in size.

bassmadrigal · 05-26-2022, 09:56 PM

Quote:

Originally Posted by half-word

Ok let's think in programmer years. Just Linux kernel already has tens of thousands of programmer years.

That means that to (re)write it, roughly one programmer would need to work tens of thousands of years. Or a team of tens of programmers would need a thousand years. Or a team of thousand programmers would work for decades. And so on.

This isn't exactly true. While the kernel does have tens of thousands of programmer years, you would not need to take all that time to translate the kernel to a new language. Many of the lines of code written in those thousands of years of coding have been removed/replaced/refactored, and you wouldn't need to recreate all the history of the kernel to get to a modern kernel.

We're still looking at an unfathomably long time to rewrite the kernel, but it would be at least an order of magnitude less than what it took to get to this point.