//My amd64 inline asm version 
#include <iostream>
using namespace std;

void my_fn(){
   const char * fl =       "/dev/vcsa1";
   const char * test_str = "          "; //make same size as fl
   int test_int = -1; //ie initialised to fail unless replaced by value 

   //1 open /dev/vcsa1 & return file descriptor in rax  
   __asm__ __volatile__(
   ".equ sys_open, 2\n"           //changed for 64bit
   ".equ O_RDWR, 02\n"          //same for 32 and 64 bit
   "mov $sys_open, %%rax\n" 
   "mov $O_RDWR, %%rcx\n" 
   "mov $0600, %%rdx\n" //read/write for user in x86. Not sure for AMD64?
   "syscall\n"                         //changed from int $0x80
   :"=b"(test_str), "=a"(test_int)
   :"b"(fl)
   ); 
  
   //test file name in rbx and returned file descriptor
   cout << test_str << endl; // /dev/vcsa1                     pass
   cout << test_int << endl; // 2 before syscall -14 after ie  fail  
}

int main(){
   my_fn();
   return 0;
}

    

;format  ELF executable
;commented out and replaced with...
format  ELF64

;entry   start
;commented out and replaced with...
public _print_str as 'print_str'

sys_exit       equ      1
sys_read       equ 3
sys_write      equ 4
sys_open       equ 5
sys_close      equ 6
sys_lseek      equ 19
SEEK_SET       equ        0
O_RDWR                equ    02o

; position to display
nasz_wiersz          equ  10
nasza_kolumna     equ     10

;start:
;commented out and replaced with...
_print_str: 

        mov     eax, sys_open           ; open the file
     mov     ebx, plik         ; file name
       mov     ecx, O_RDWR       ; read and write
  mov     edx, 600o         ; read and write for the user
     int     80h                           ; open

    cmp     eax, 0
      jl      .koniec

 mov     ebx, eax                      ; file handle
 mov     eax, sys_read           ; read the file (console attributes first)
  mov     ecx, konsola            ; where to read
     mov     edx, 4                     ; how many bytes to read
 int     80h


 mov     eax, sys_lseek             ; seek to the correct psition
    movzx   ecx, byte [l_kolumn]    ; zero extends dest operand to size of source operand
       imul    ecx, nasz_wiersz
    add     ecx, nasza_kolumna      ; ECX=row*row length + column
       shl     ecx, 1                        ; ECX *= 2, because there are 2 bytes
                                                ; on the screen for each character:
                              ; the character and its attribute
   add     ecx, 4                        ; +4, because we're moving from
                                                     ; the beginning of the file
  mov     edx, SEEK_SET              ; start at the beginning of the file
     int     80h


 mov     eax, sys_write             ; writing to the file
    mov     ecx, znak                     ; what to write
       mov     edx, 2                        ; how many bytes to write
     int     80h

     mov     eax, sys_close             ; close the file
 int     80h


         xor     eax, eax                         ; EAX = 0 = no errors

.koniec:
  mov     ebx, eax
    mov     eax, sys_exit
       int     80h                              ; exit with zero code or the error,
                                                       ; from opening the file

plik      db      "/dev/vcsa1", 0               ; first text console file
                                                  ; attributes of the console:
konsola:
l_wierszy    db      0
l_kolumn   db      0
kursor_x   db      0
kursor_y   db      0

                       ; character with the attribute we're going to display:
znak             db      "*"                           ;<<<<<<HERE
atrybut                db      43h             ; skyblue on red  ;<<<<<<HERE

    

/*
this file is a .cpp skeleton just to link object file of fasm konsola.asm
*/
using namespace std;
extern "C" void print_str();
int main(){
   print_str();
   return 0;
} 
    

#!/bin/sh
#create the exe "linked_konsola"
./fasm linked_konsola_fasm.asm linked_konsola_fasm.o
g++ -c linked_konsola_cpp.cpp
g++ -o linked_konsola linked_konsola_fasm.o linked_konsola_cpp.o
    

//const      char *      fasm = "fasm";    // memory:read, pointer:read-write
//      char *const fasm = "fasm";      // memory:read-write, pointer:read
const   char *const fasm = "fasm";      // memory:read, pointer:read

const char *readptr;
char *writeptr;

int main()
{
//  fasm = "masm";      // can't reassign pointer
//  fasm[0] = 'm';      // can't write to read-only

    readptr = fasm;     // allowed, since readptr points-to-const
//  readptr[0] = 'm';   // still can't write to read-only

    writeptr = fasm;    // allowed in C (with warning), disallowed in C++
    writeptr[0] = 'm';  // might work, might crash - implementation specific
}    

void Update_screen(){
   for each machine in vector
      for each part in machine
            asm bit (
               suck part.char into reg a
               suck part.fg_bg into reg b
               etc
               write char directly to video ram without call overhead     
}
    

As such I need to loop through such vectors and interrogate their nested objects for the display information. I don't fancy looping through these structures in asm unless there's an easy way and don't want to incur the cost of a call to asm for each part that needs redisplaying.

I did a .S of an example c "open file" program which used the relevant include files.
It looked a nightmare and I hadn't got a clue what some of the routines were that were being called.
I would have thought the routines were corruption but for the word "call" preceding them.

//My amd64 inline asm version
//this now returns a file descriptor of 3
#include <iostream>
using namespace std;

void my_fn(){
   const char * fl =       "/dev/vcsa1";
   const char * test_str = "          "; //make same size as fl
   int test_int = -1;                    //fails unless replaced by value 
   unsigned char buf[] = {0,0,0,0};

   //1 open /dev/vcsa1 & return file descriptor in rax  
   __asm__ __volatile__(
   ".equ sys_open,2\n"
   ".equ O_RDWR,02\n"
   "movq $sys_open,%%rax\n" 
   "movq $O_RDWR,%%rsi\n" 
   "movq $0600,%%rdx\n" //read/write for user in x86. Not sure for AMD64?
   "syscall\n" 
   :"=D"(test_str),"=a"(test_int)
   :"D"(fl)              //rdi
   :"rsi","rdx","rcx","r10","r11","cc" //Is this enough
   ); 

   //cout << test_str << endl; // /dev/vcsa1    ie pass
   //cout << test_int << endl; // 3             ie pass

   //read 1st 4 bytes of file into buf[]
   __asm__ __volatile__(
   "movq %%rax, %%rsi\n"   //returned file descriptor into rsi
   "movq $0,%%rax\n"      //syscall read into rax
   "movq $4,%%rdx\n"      //qty of bytes to read into rdx
   "syscall\n" 
   :"=a"(test_int)
   :"D"(&buf[0])          //ptr of where to place 1st byte into rdi
   :"rsi","rdx","rcx","r10","r11","cc"
   );
   cout << test_int << endl; //returning -9 expected 4   ie fail 
}

int main(){
   my_fn();
   return 0;
}