There is no right way or wrong way!
...
So there's nothing wrong with limiting your focus initially to a 16-bit real mode environment (which incidentally to this day every X86 CPU still sets up on power-up).
...
Because of all the inconsistencies (idiosyncrasies?) in the X86 architecture, a good grounding in the 16-bit fundamentals won't ever do you any harm!

Though I'd honestly recommend (Free)Pascal if all you want to do is learn general computing principles. In particular, it supports inline asm, and it even has a i8086-msdos (cross-)target nowadays. (Just FYI, "asmmode intel" is default for "mode tp" [turbo].)

{$mode tp}
program d2x;
var n:byte; err:integer;
  procedure hexbyte(b: byte); assembler;
  asm
    int3
    mov al,b
    mov dx,ax
    mov cl,4
    shr al,cl
    cmp al,10
    sbb al,105
    das
    int 29h
    mov ax,dx
    and al,15
    cmp al,10
    sbb al,105
    das
    int 29h
  end;
begin if paramcount=0 then halt;
  val(paramstr(1),n,err); hexbyte(n); writeln('=',hexstr(n,2))
end.
    

Yuck, AT&T syntax is awful.

Changes in 2.10 [year 2000??]:

* A new pseudo-op .intel_syntax has been implemented to allow gas to parse i386
assembly programs with intel syntax.

typedef struct { char low,high; } grouped_char; 

char getHigh(grouped_char chars) {
  char result;
    
  asm(
#ifndef INTEL
    "shr $8,%%ax\n"      // bitshift AH into AL
    "mov %%al,%%bl\n"    // BL <-- AL
#else
    ".intel_syntax noprefix\n"
    "shr ax,8\n"
    "mov bl,al\n"
    ".att_syntax prefix\n"
#endif
     : "=b"  (result)    // resulting char is found in BL
     : "a"   (chars)     // pass char group parameter into AX
  );
  return result;
}
    

Yuck, AT&T syntax is awful.

radarblue, I feel like you don't have focus on what exactly you're trying to learn. Is it general programming or 8086/386 or C or Windows or ... ?

Emulators can take you to some point ahead, but that won't be far. VM can give you that fake impression but in the end you'll bump into similar restrictions.

So my suggestions, buy a 32-bit PC or if u already have one, put it in a vault. They are good for 16-bit programming. Treasure it like hell. Besides, 32-bit programming still has 50 years more to go before it becomes completely obsolete (call this system error's Law. Forget Newton's Law).

Next suggestion, start anew with 64-bit processors / programming. It's the most ideal bit-ness for most human computational needs and will stay for the next 150-300 years. You can't go wrong with it. FASM will become FASM++ by then.

I think I will do that. Dig up my old Pentium Win32 PC from the basement and start programming on that machine instead, and also learn to get around in DOS (its about time). I have to make some moves to make this work. To program onto the actual CPU is the way to go, so I can proceed in my study.

Wait, are you sure your current PC doesn't have a BIOS? My 2009/2010-ish machines both have BIOSes, despite being 64-bit capable, so I can easily boot DOS natively (even via USB). Heck, the Dell laptop has a diagnostics partition that uses (modified) DR-DOS (aka, DRMK).

I didn't mean to unfairly scare you off. I don't have any UEFI machines, so from what I've heard, you can't always rely on a BIOS-like (CSM) compatibility module. It's possible that yours is fine.

But you don't explicitly need a 32-bit only machine.

"50 years more"?? That's not true at all. Many 32-bit (even 64-bit) cpus have been obsoleted in the past decade. Look at Alpha, Itanium, VAX, PPC (32-bit only), etc. I would not rely on any 32-bit lasting beyond the next few years. It's quite clear (to me) that most people (OS and compiler devs) want to throw it away too.

#include <stdio.h> 
//C . GCC .  
int main() 
{  
        int x,y,z,w; 
        printf ("Enter 2 integers : "); 
        scanf ("%d %d",&x,&y);
        printf("before xchg\nx y = %d %d\n",x,y);
        
        asm ("mov $0,%%al"
            :"=a"(z)
            );
        
        asm ("mov %%bl,%%al"
            :"=a"(z)
            :"b"(x),"a"(z)
            ); 
        printf("x = z = %d\n",z); 
        
            asm ("mov $0,%%bl"   
            :"=b"(w)            
            );
        
        asm ("mov %%cl,%%bl"   
            :"=b"(w)
            :"c"(y),"b"(w) 
            ); 
            
       printf("y = w = %d\n",w);  
       
        asm ("xchg %%bl,%%al"   // define instruction and registers. 
            :"=a"(w)            // define dst register with variable. 
            : "b"(z),"a"(w)     // define operation registers. 
            ); 
             
        printf("after xchg\nw z = %d %d",w,z); 
        return 0; 
}    

I don't agree with this one. Computing industry is in its golden years with 32-bit CPUs. People have invested trillions and probably more. Software authors are largely reluctant to take the 64-bit leap. Colleges, schools, and universities, are obviously not ready to let go their 32-bit PC labs, manuals, textbooks, courseware anytime soon. That's sounds like an awful lots of monies for not so obvious benefits.

Companies are not willing to re-train existing employeess. Not to mention book publishers, telcos, web hosting companies, call centers, workplaces etc... these people have no pressing needs to switch to 64-bit world. This thread serves as the best example showing how difficult it is to even totally kill 16-bit spirit looonng after that 80286 era. Stackoverflow is still receiving steady streams of 16-bit questions from all over and now you want to kill 32-bitness that fast? Not a chance bro. Unlike 32-bit CPUs that are reluctant to 16-bit stuff, 64-bit CPUs are extremely permissive to 32-bit thingy. So yeah, based on these, 32-bitness is not going anywhere anytime soon. I give it 50 years and that's minimum.

There has to be another compiler ... ! Than the GCC . Im actually considering the Intel Parallell Studio XE. Gonna do some more research and see if it does me any good. It seems to lead to Microsoft Visual Studio. Will this be locked to MASM inline in that case ? Intel is NOT Microsoft.

Just look at it, its hideous, and it doesnt exchange the numbers.

mov al,0
mov al,bl ; clobbers the 0
printf ; clobbers almost everything

mov bl,0
mov bl,cl ; clobbers the 0
printf ; clobbers almost everything
       
xchg al,bl ; your values weren't saved and thus were overwritten
printf ; probably prints garbage
    

radarblue wrote:

Just look at it, its hideous, and it doesnt exchange the numbers.

You're (apparently) doing this:

Code:

mov al,0
mov al,bl ; clobbers the 0
printf ; clobbers almost everything

mov bl,0
mov bl,cl ; clobbers the 0
printf ; clobbers almost everything
       
xchg al,bl ; your values weren't saved and thus were overwritten
printf ; probably prints garbage
    

I haven't run this natively, but that's a quick guess.

     #include <stdio.h> 
     int main()
//openwatcom v2.0 . bnnt64 . win10.
//Exhange 2 numbers using Assembly in C.
     { 
        int x,y,rslt1,rslt2,a;
        
        printf ("Enter 2 numbers: ");
        scanf ("%d %d",&x,&y);
        printf ("x=%d y=%d",x,y);

        __asm
        #pragma aux // <------------------Macro Error for the Assembler.
          
        "    eax,x              "\
        "    ebx,y              "\
        "    xchg x,y           "\
        "    mov rslt1,x        "\
        "    mov rslt2,y        "\
           

         printf ("x=%d y=%d",rslt1,rslt2);
         printf("Press any key to exit...\n"); 
         scanf ("%d",a); // prohibits program to quit.
         return 0;
     }    

;xchg_2_characters . EMU8086
.stack
.data
parlist label byte  ; parameter list
maxlen db 7
actlen db ?
opfld db 7 dup (?) ; operand field

prmpt db 0dh,0ah, "Enter 4 characters:$"
rslt1 db 0dh,0ah, "Before exchange =            $"
rslt2 db 0dh,0ah, "After exchange =             $"

.code
proc
    ;set up program
    mov ax,@data
    mov ds, ax
    
    ;read prompt
    mov ah,09h      ;display string
    lea dx,prmpt    ;load adress of prompt DX data register
    int 21h         ;DOS interrupt
    
    ;keyboard return to enter characters
    mov ah,0ah      ; buffered keyboard input
    lea dx,parlist  ; load adress of parlist
    int 21h
    
    ;store characters from opfld to bl and bh
    mov bl,opfld    ;get 1t character
    mov bh,opfld+1  ;get 2nd character
     
    mov [di+1],bl
    mov [di+2],bh
    
    mov cl,[di+1]
    mov ch,[di+2] 
   
    ;display original character
    mov rslt1+20,bl
    mov rslt1+22,bh 
    
    mov bl,opfld+2
    mov bh,opfld+3  
    
    mov [di+3],bl
    mov [di+4],bh 
    
    mov rslt1+24,bl
    mov rslt1+26,bh
    
    mov ah,09h
    lea dx,rslt1
    int 21h
    
    ;exchange characters
    xchg cl,ch
    
    ;display swapped characters
    mov rslt2+20,cl
    mov rslt2+22,ch 
    
    mov cl,[di+3]
    mov ch,[di+4]
    
    xchg cl,ch 
    
    mov rslt2+24,cl
    mov rslt2+26,ch
        
    mov ah,09h
    lea dx,rslt2
    int 21h
    
    endp
    

I read thru the getting started on the Openwatcom and it is up and running in 64bit, win10. However making an Assembly inline, seems to be using a macro called #PRAGMA AUX. And certainly there is a special way to claim the ASM. that I find nowhere.

LINK2 : http://www.azillionmonkeys.com/qed/watfaq.shtml#6

Starting with version 11.0 WATCOM C/C++ supports the "_asm" language extension, purely as a compatibility feature as most other PC based C compilers use it. WATCOM still recommends the use of the #pragma aux method since it gives you and the compiler far more control. Refer to the online documentation.

//openwatcom v2.0 . bnnt64 . win10.

To learn C is just an excuse to learn Assembly. The inline is part of the deal.

Paul Hsieh wrote : Starting with version 11.0 WATCOM C/C++ supports the "_asm" language extension,

Quote:

Paul Hsieh wrote : Starting with version 11.0 WATCOM C/C++ supports the "_asm" language extension,

... He has to mean Watcom v1.1 ?

I have a question. when somebody makes a computer game for instance. Do they have to include the Compiler into the program. For as I understand it the OS doesnt come with compilers, neither can a computer game know where the different compilers are in the machine, if there are compilers installed ?