Assembly language - How it works

Question

I am really new at learning assembly language and just started digging in to it so I was wondering if maybe some of you guys could help me figure one problem out. I have a homework assignment which tells me to compare assembly language instructions to c code and tell me which c code is equivalent to the assembly instructions. So here is the assembly instructions:

pushl %ebp // What i think is happening here is that we are creating more space for the function.
movl %esp,%ebp // Here i think we are moving the stack pointer to the old base pointer.
movl 8(%ebp),%edx // Here we are taking parameter int a and storing it in %edx
movl 12(%ebp),%eax // Here we are taking parameter int b and storing it in %eax
cmpl %eax,%edx // Here i think we are comparing int a and b ( b > a ) ?
jge .L3 // Jump to .L3 if b is greater than a - else continue the instructions
movl %edx,%eax // If the term is not met here it will return b
.L3:
movl %ebp,%esp // Starting to finish the function
popl %ebp // Putting the base pointer in the right place
ret // return

I am trying to comment it out based on my understanding of this - but I might be totally wrong about this. The options for C functions which one of are suppose to be equivalent to are:

int fun1(int a, int b)
{
unsigned ua = (unsigned) a;
if (ua < b)
return b;
else
return ua;
}
int fun2(int a, int b)
{
if (b < a)
return b;
else
return a;
}
int fun3(int a, int b)
{
if (a < b)
return a;
else
return b;
}

I think the correct answer is fun3 .. but I'm not quite sure.

Answer 1

Now for starters, let me help you; a lot; a whole lot.

You have good comments that help both you and me and everyone else tremendously, but they are so ugly that reading them is painful.

Here's how to fix that: white space, lots of it, blank lines, and grouping the instructions into small groups that are related to each other.

More to the point, after a conditional jump, insert one blank line, after an absolute jump, insert two blank lines. (Old tricks, work great for readability)

Secondly, line up the comments so that they are neatly arranged. It looks a thousand times better.

Here's your stuff, with 90 seconds of text arranging by me. Believe me, the professionals will respect you a thousand times better with this kind of source code...

    pushl %ebp              //   What i think is happening here is that we are creating more space for the function.
    movl %esp,%ebp          //   Here i think we are moving the stack pointer to the old base pointer.
    
    movl 8(%ebp),%edx       //   Here we are taking parameter int a and storing it in %edx
    movl 12(%ebp),%eax      //   Here we are taking parameter int b and storing it in %eax
    
    
    cmpl %eax,%edx          //   Here i think we are comparing int a and b ( b > a ) ?
                            //   No, Think like this: "What is the value of edx with respect to the value of eax ?"
    
    jge .L3                 //   edx is greater, so return the value in eax as it is
    
    movl %edx,%eax          //   If the term is not met here it will return b
                            //   (pssst, I think you're wrong; think it through again)
    
    .L3:
    
    movl %ebp,%esp          //   Starting to finish the function
    popl %ebp               //   Putting the base pointer in the right place
    ret                     //   return

Now, back to your problem at hand. What he's getting at is the "sense" of the compare instruction and the related JGE instruction.

Here's the confuse-o-matic stuff you need to comprehend to survive these sorts of "academic experiences"

This biz, the cmpl %eax,%edx instruction, is one of the forms of the "compare" instructions

Try to form an idea something like this when you see that syntax, "...What is the value of the destination operand with respect to the source operand ?..."

Caveat: I am absolutely no good with the AT&T syntax, so anybody is welcome to correct me on this.

Anyway, in this specific case, you can phrase the idea in your mind like this...

"...I see cmpl %eax,%edx so I think: With respect to eax, the value in edx is..."

You then complete that sentence in your mind with the "sense" of the next instruction which is a conditional jump.

The paradigmatic process in the human brain works out to form a sentence like this...

"...With respect to eax, the value in edx is greater or equal, so I jump..."

So, if you are correct about the locations of a and b, then you can do the paradigmatic brain scrambler and get something like this...

"...With respect to the value in b, that value in a is greater or equal, so I will jump..."

To get a grasp of this, take note that JGE is the "opposite sense" if you will, of JL (i.e., "Jump if less than")

Okay, now it so happens that return in C is related to the ret instruction in assembly language, but it isn't the same thing.

When C programmers say "...That function returns an int..." what they mean is...

• The assembly language subroutine will place a value in Eax
• The subroutine will then fix the stack and put it back in neat order
• The subroutine will then execute its Ret instruction

One more item of obfuscation is thrown in your face now.

These following conditional jumps are applicable to Signed arithmetic comparison operations...

• JG
• JGE
• JNG
• JL
• JLE
• JNL

There it is ! The trap waiting to screw you up in all this !

Do you want to do signed or unsigned compares ???

By the way, I've never seen anybody do anything like that first function where an unsigned number is compared with a signed number. Is that even legal ?

So anyway, we put all these facts together, and we get: This assembly language routine returns the value in a if it is less than the value in b otherwise it returns the value in b.

These values are evaluated as signed integers.

(I think I got that right; somebody check my logic. I really don't like that assembler's syntax at all.)

So anyway, I am reasonably certain that you don't want to ask people on the internet to provide you with the specific answer to your specific homework question, so I'll leave it up to you to figure it out from this explanation.

Hopefully, I have explained enough of the logic and the "sense" of comparisons and the signed and unsigned biz so that you can get your brain around this.

Oh, and disclaimer again, I always use the Intel syntax (e.g., Masm, Tasm, Nasm, whatever) so if I got something backwards here, feel free to correct it for me.