how are multiple chunks of 8-bit words converted to a single number?

Question

Ok first of all, I know that if i have a 8 bit computer it can only handle 8 bit numbers, not higher than 8, but I know that it is still possible to represent a 16-bit number or even a 32,64,128-bit number by allocating more memory in ram. But for the sake of simplicity lets just use a 16 bit number as an example.

Let's say we have a 16 bit number in ram like this:

12 34 <-- That's Hexadecimal btw

Let's also write it in binary just in case yall prefer binary form:

00010010 00110100 <-- Binary
              &
      4660 in decimal

Now, we know that the computer cant understand this big number(4660) as one single number, because the computer can only understand 8-bit numbers which only goes up to 255. So the byte on the right would stay as it is:

00110100 <-- 52 in decimal

but the left byte:

00010010 <-- would be 18 if it was the byte on the right, 
             but since it is on the left, it means that its
             4608 

So my question is, how does the computer read the second byte as 4608 if it can only understand numbers that are lower than 255, and then after that how does it interprets those two bytes as a single number(4660)?

Thanks, if you are confused feel free to ask me down in the comments. I made it as clear as possible.

Answer 1

well this is more programing question then HW architecture as the CPU only does 8bit operations in your test case and has no knowledge about 16bit. Your example is: 16bit arithmetics on 8bit ALU and is usually done by splitting to High and Low half of number (and joining latter). That can be done in more ways for example here few (using C++):

1. transfer

   const int _h=0; // MSB location
   const int _l=1; // LSB location
   BYTE h,l; // 8 bit halves
   WORD hl;  // 16 bit value
   h=((BYTE*)(&hl))[_h];
   l=((BYTE*)(&hl))[_l];
   // here do your 8bit stuff on h,l
   ((BYTE*)(&hl))[_h]=h;
   ((BYTE*)(&hl))[_l]=l;
   

   You need to copy from/to the 8bit/16bit "register" copies which is slow but sometimes can ease up things.

2. pointers

   const int _h=0; // MSB location
   const int _l=1; // LSB location
   WORD hl;  // 16 bit value
   BYTE *h=((BYTE*)(&hl))+_h;
   BYTE *l=((BYTE*)(&hl))+_l;
   // here do your 8bit stuff on *h,*l or h[0],l[0]
   

   you do not need to copy anything but use pointer access *h,*l instead h,l. The pointer initialization is done just once.

3. union

   const int _h=0; // MSB location
   const int _l=1; // LSB location
   union reg16 
    {
    WORD dw;  // 16 bit value
    BYTE db[2]; // 8 bit values
    } a;
   // here do your 8bit stuff on a.db[_h],a.db[_l]
   

   This is the same as #2 but in more manageable form

4. CPU 8/16 bit registers

   Even 8 bit CPU's have usually 16 bit registers accesible by its half or even full registers. For example on Z80 you got AF,BC,DE,HL,PC,SP most of which are directly accessible by its half registers too. So there are instructions working with hl and also instructions working with h,l separately. On x86 it is the same for example:

   mov AX,1234h
   

   Is the same (apart of timing and possibly code length) as:

   mov AH,12h
   mov AL,34h
   

Well that is conversion between 8/16 bit in a nutshell but I assume you are asking more about how the operations are done. That is done with use of Carry flag (which is sadly missing from most of higher languages then assembler). For example 16 bit addition on 8 bit ALU (x86 architecture) is done like this:

// ax=ax+bx
add al,bl
adc ah,bh

So first you add lowest BYTE and then highest + Carry. For more info see:

• Cant make value propagate through carry

For more info about how to implement other operations see any implementation on bignum arithmetics.

[Edit1]

Here small C++ example of how to print 16 bit number with only 8 bit arithmetics. You can use 8 bit ALU as a building block to make N*8 bit operations in the same way as I did the 16 bit operations ...

//---------------------------------------------------------------------------
// unsigned 8 bit ALU in C++
//---------------------------------------------------------------------------
BYTE cy;                    // carry flag cy = { 0,1 }
void inc(BYTE &a);          // a++
void dec(BYTE &a);          // a--
BYTE add(BYTE a,BYTE b);    // = a+b
BYTE adc(BYTE a,BYTE b);    // = a+b+cy
BYTE sub(BYTE a,BYTE b);    // = a-b
BYTE sbc(BYTE a,BYTE b);    // = a-b-cy
void mul(BYTE &h,BYTE &l,BYTE a,BYTE b);    // (h,l) = a/b
void div(BYTE &h,BYTE &l,BYTE &r,BYTE ah,BYTE al,BYTE b);   // (h,l) = (ah,al)/b ; r = (ah,al)%b
//---------------------------------------------------------------------------
void inc(BYTE &a) { if (a==0xFF) cy=1; else cy=0; a++; }
void dec(BYTE &a) { if (a==0x00) cy=1; else cy=0; a--; }
BYTE add(BYTE a,BYTE b)
    {
    BYTE c=a+b;
    cy=DWORD(((a &1)+(b &1)   )>>1);
    cy=DWORD(((a>>1)+(b>>1)+cy)>>7);
    return c;
    }
BYTE adc(BYTE a,BYTE b)
    {
    BYTE c=a+b+cy;
    cy=DWORD(((a &1)+(b &1)+cy)>>1);
    cy=DWORD(((a>>1)+(b>>1)+cy)>>7);
    return c;
    }
BYTE sub(BYTE a,BYTE b)
    {
    BYTE c=a-b;
    if (a<b) cy=1; else cy=0;
    return c;
    }
BYTE sbc(BYTE a,BYTE b)
    {
    BYTE c=a-b-cy;
    if (cy) { if (a<=b) cy=1; else cy=0; }
    else    { if (a< b) cy=1; else cy=0; }
    return c;
    }
void mul(BYTE &h,BYTE &l,BYTE a,BYTE b)
    {
    BYTE ah,al;
    h=0; l=0; ah=0; al=a;
    if ((a==0)||(b==0)) return;
    // long binary multiplication
    for (;b;b>>=1)
        {
        if (BYTE(b&1))
            {
            l=add(l,al);    // (h,l)+=(ah,al)
            h=adc(h,ah);
            }
        al=add(al,al);      // (ah,al)<<=1
        ah=adc(ah,ah);
        }
    }
void div(BYTE &ch,BYTE &cl,BYTE &r,BYTE ah,BYTE al,BYTE b)
    {
    BYTE bh,bl,sh,dh,dl,h,l;
    // init
    bh=0; bl=b; sh=0;   // (bh,bl) = b<<sh so it is >= (ah,al) without overflow
    ch=0; cl=0; r=0;    // results = 0
    dh=0; dl=1;         // (dh,dl) = 1<<sh
    if (!b) return;     // division by zero error
    if ((!ah)&&(!al)) return;   // division of zero
    for (;bh<128;)
        {
        if (( ah)&&(bh>=ah)) break;
        if ((!ah)&&(bl>=al)) break;
        bl=add(bl,bl);
        bh=adc(bh,bh);
        dl=add(dl,dl);
        dh=adc(dh,dh);
        sh++;
        }
    // long binary division
    for (;;)
        {
        l=sub(al,bl);   // (h,l) = (ah,al)-(bh,bl)
        h=sbc(ah,bh);
        if (cy==0)      // no overflow
            {
            al=l; ah=h;
            cl=add(cl,dl);  // increment result by (dh,dl)
            ch=adc(ch,dh);
            }
        else{           // overflow -> shoft right
            if (sh==0) break;
            sh--;
            bl>>=1;     // (bh,bl) >>= 1
            if (BYTE(bh&1)) bl|=128;
            bh>>=1;
            dl>>=1;     // (dh,dl) >>= 1
            if (BYTE(dh&1)) dl|=128;
            dh>>=1;
            }
        }
    r=al;       // remainder (low 8bit)
    }
//---------------------------------------------------------------------------
// print 16bit dec with 8bit arithmetics
//---------------------------------------------------------------------------
AnsiString prn16(BYTE h,BYTE l)
    {
    AnsiString s="";
    BYTE r; int i,j; char c;
    // divide by 10 and print the remainders
    for (;;)
        {
        if ((!h)&&(!l)) break;
        div(h,l,r,h,l,10);  // (h,l)=(h,l)/10; r=(h,l)%10;
        s+=char('0'+r);         // add digit to text
        }
    if (s=="") s="0";
    // reverse order
    i=1; j=s.Length();
    for (;i<j;i++,j--) { c=s[i]; s[i]=s[j]; s[j]=c; }
    return s;
    }
//---------------------------------------------------------------------------

I use VCL AnsiString for text storage you can change it to what ever string or even char[] instead. You need to divide the whole number not just the BYTE's separately. See how the div function works. Here example of least significant digit of 264 print 264%10...

a = 264 = 00000001 00001000 bin
b =  10 = 00000000 00001010 bin
d =   1 = 00000000 00000001 bin
// apply shift sh so b>=a 
a = 00000001 00001000 bin
b = 00000001 01000000 bin
d = 00000000 00100000 bin
sh = 5
// a-=b c+=d while a>=b
// a<b already so no change
a = 00000001 00001000 bin b = 00000001 01000000 bin c = 00000000 00000000 bin d = 00000000 00100000 bin
// shift right
b = 00000000 10100000 bin d = 00000000 00010000 bin sh = 4
// a-=b c+=d while a>=b
a = 00000000 01101000 bin c = 00000000 00010000 bin
// shift right
b = 00000000 01010000 bin d = 00000000 00001000 bin sh = 3
// a-=b c+=d while a>=b
a = 00000000 00011000 bin c = 00000000 00011000 bin
// shift right
b = 00000000 00101000 bin d = 00000000 00000100 bin sh = 2
b = 00000000 00010100 bin d = 00000000 00000010 bin sh = 1
// a-=b c+=d while a>=b
a = 00000000 00000100 bin c = 00000000 00011010 bin
// shift right
b = 00000000 00001010 bin d = 00000000 00000001 bin sh = 0
// a<b so stop a is remainder -> digit = 4
//now a=c and divide again from the start to get next digit ...

Answer 2

By interpreting them as base-256.

>>> 18*256 + 52
4660