Re: Any more graceful way to saturate adds?

In article 
<25740676-bb54-4871-b103-d3b7135e4f28@[EMAIL PROTECTED]
>
           spamtrap@[EMAIL PROTECTED]
 "Jim Leonard" writes:

> On Apr 22, 1:01 pm, Terje Mathisen  <spamt...@[EMAIL PROTECTED]
> wrote:
> > BTW, there is a very sneaky way to avoid that initial jump:
> >
> > Instead of
> >
> >   jmp short start
> >   next:
> >     stosb
> > start:
> >
> > you can instead write:
> >
> >    mov al,0AAh
> > org $-1         ; Back up one byte into the immediate constant above
> > next:
> >    stosb
> >
> > I.e. on the first iteration we do a dummy two-byte instruction with a
> > one-byte immediate, which we then make sure contains the STOSB opcode
byte.
> >
> > The gain is that we save one opcode byte (MOV instead of JMP SHORT)
and
> > a taken branch, so the actual cost of rotating the loop like this is 8
> > cycles on the first iteration, instead of 17, and each iteration saves
> > two opcode bytes or 8 cycles.
> 
> I hate to seem more daft than I already am, but after re-reading the
> above for a week I still don't get the trick.

The "trick" is to locate the next: label in the middle of the 
instruction 'mov al,imm8' -- the 'org $-1' winds back the program 
counter one location and assembles the STOSB opcode in the 
location occupied by the imm8 value of the previous instruction.  
This results in a benign 'mov al,0AAh' first time through the 
code (benign in the sense that AL will soon after be loaded with 
the proper value) but when looping back to the next: label the 
code will find a STOSB (i.e. jumps into the middle of the mov 
instruction).

>  I thought ORG was for
> specifying where the assembler assumes the binary code will get
> loaded; how does that save two opcode bytes per iteration?

This saving comes from having a single STOSB at the "top" of the 
loop; the alternative earlier loop had 3 STOSB instructions (one 
in each branch) -- hence the saving of 2 x STOSB.

Very neat and goes some way to justify my earlier comment about 
Terje's little finger ;-)

Pete

Incidentally, I've used the 'org $-1' technique in the past for 
self-modifying code to jump to alternative addresses (like a 
switch() in C).  Something like

        jmp short +2
        org $-1
disp    db ?

proc1:  some code
        ret
proc2:  more code etc...
        ret

Then, at some point before the jmp you just load up the 
displacement byte (disp) with 0, (proc2-proc1), (proc3-proc1), 
etc. according to which section of code you want to jump to.  
Not much use on modern processors I guess, but it worked well on 
the 8086 and z80!
-- 
   "We have not inherited the earth from our ancestors,
    we have borrowed it from our descendants."