`mov esp,ebp` sets the stack pointer to the base frame address, effectively releasing the whole frame. (Don&#39;t forget that this is Intel syntax, the destination comes first.) If you didn&#39;t do it, once you call `ret`, you would still be using the called function&#39;s stack frame with your calling function, with crashtastic consequences.


I think your issue is the fact that there are two different ways of writing x86 assembly. One is the AT&amp;T notation and the other is the Intel notation. The order of the arguments to an instruction are reversed in Intel notation as opposed to AT&amp;T. Your version of the assembly appears to be in Intel notation, which means that `mov esp, ebp` actaully moves the value in `ebp` to `esp`. In the more logical (in my opinion) AT&amp;T notation it would be `mov %ebp, %esp`.

The compiler use this instruction to free the used space by the function in the stack, the `leave` instruction has the same behavior as `mov esp, ebp` with `pop ebp`.

Update row with data from another row in the same table

The problem -

    @is_premium_user
    def sample_view:
              .......
              ......

I want certain views accesible to only the premium users of the website.    
And how can I use this decorator across various applications in my project?



How to write a custom decorator in django?

It&#39;s said that the `leave` instruction is the same as :

    mov esp,ebp
    pop ebp

But what is `mov esp,ebp` here for? It doesn&#39;t seem valid to me...

Why does leave do &quot;mov esp,ebp&quot; in x86 assembly?

It's said that the <code>leave</code> instruction is the same as :
<pre><code class="hljs language-perl">mov esp,ebp
pop ebp
</code></pre>
But what is <code>mov esp,ebp</code> here for? It doesn't seem valid to me...

How are everyday machines (not so much computers and mobile devices as appliances, digital watches, etc) programmed? What kind of code goes into the programming of a Coca-Cola vending machine? How does my coffee maker accept a pre-programmed time and begin brewing a pot of coffee hours later, when that time arrives?

Do these kinds of machines have operating systems inside of them, or is it something even more basic? Are they written in Assembly, C, or some other language?

And, I would really like to find some resource that lists these operating systems or underlying code systems, possibly even with source code if possible. If anyone knows of such a resource (searching yielded nothing for me), that would be fantastic.

How are everyday machines programmed?

&gt;https://stackoverflow.com/questions/5554725/which-value-is-better-to-use-boolean-true-or-integer-1

The above topic made me do some experiments with `bool` and `int` in `if` condition. So just out of curiosity I wrote this program:

    int f(int i) 
    {
    	if ( i ) return 99;   //if(int)
    	else  return -99;
    }
    int g(bool b)
    {
    	if ( b ) return 99;   //if(bool)
    	else  return -99;
    }
    int main(){}

`g++ intbool.cpp -S` generates asm code for each functions as follows:

 - asm code for `f(int)`

        __Z1fi:
           LFB0:
     	         pushl	%ebp
           LCFI0:
    	          movl	%esp, %ebp
           LCFI1:
    	          cmpl	$0, 8(%ebp)
    	          je	L2
    	          movl	$99, %eax
    	          jmp	L3
           L2:
    	          movl	$-99, %eax
           L3:
    	          leave
           LCFI2:
    	          ret


 - asm code for `g(bool)`

        __Z1gb:
           LFB1:
    	          pushl	%ebp
           LCFI3:
    	          movl	%esp, %ebp
           LCFI4:
    	          subl	$4, %esp
           LCFI5:
    	          movl	8(%ebp), %eax
    	          movb	%al, -4(%ebp)
    	          cmpb	$0, -4(%ebp)
    	          je	L5
    	          movl	$99, %eax
    	          jmp	L6
           L5:
    	          movl	$-99, %eax
           L6:
    	          leave
           LCFI6:
    	          ret


Surprisingly, `g(bool)` generates more `asm` instructions! Does it mean that `if(bool)` is little slower than `if(int)`? I used to think `bool` is especially designed to be used in conditional statement such as `if`, so I was expecting `g(bool)` to generate less asm instructions, thereby making `g(bool)` more efficient and fast. 

EDIT:

I&#39;m not using any optimization flag as of now. But even absence of it, why does it generate more asm for `g(bool)` is a question for which I&#39;m looking for a reasonable answer. I should also tell you that `-O2` optimization flag generates exactly same asm. But that isn&#39;t the question. The question is what I&#39;ve asked.

---



Which is faster : if (bool) or if(int)?

Starting with Pentium Pro (P6 microarchitecture), Intel redesigned it&#39;s microprocessors and used internal RISC core under the old CISC instructions. Since Pentium Pro all CISC instructions are divided into smaller parts (uops) and then executed by the RISC core. 

At the beginning it was clear for me that Intel decided to hide new internal architecture and force programmers to use &quot;CISC shell&quot;. Thanks to this decision Intel could fully redesign microprocessors architecture without breaking compatibility, it&#39;s reasonable.

However I don&#39;t understand one thing, why Intel still keeps an internal RISC instructions set hidden for so many years? Why wouldn&#39;t they let programmers use RISC instructions like the use old x86 CISC instructions set? 

If Intel keeps backward compatibility for so long (we still have virtual 8086 mode next to 64 bit mode), Why don&#39;t they allow us compile programs so they will bypass CISC instructions and use RISC core directly? This will open natural way to slowly abandon x86 instructions set, which is deprecated nowadays (this is the main reason why Intel decided to use RISC core inside, right?).

Looking at new Intel &#39;Core i&#39; series I see, that they only extends CISC instructions set adding AVX, SSE4 and others.

Why does Intel hide internal RISC core in their processors?

What is the difference between the `enter` and
    
    push ebp
    mov  ebp, esp
    sub  esp, imm

instructions? Is there a performence difference? If so, which is faster and why do compilers always use the latter?

Similarily with the `leave` and

    mov  esp, ebp
    pop  ebp

instructions.

&quot;enter&quot; vs &quot;push ebp; mov ebp, esp; sub esp, imm&quot; and &quot;leave&quot; vs &quot;mov esp, ebp; pop ebp&quot;

In 32bit, we had 8 &quot;general purpose&quot; registers. With 64bit, the amount doubles, but it seems independent of the 64bit change itself.  
Now, if registers are so fast (no memory access), why aren&#39;t there more of them naturally? Shouldn&#39;t CPU builders work as many registers as possible into the CPU? What is the logical restriction to why we only have the amount we have?

If registers are so blazingly fast, why don&#39;t we have more of them?

When I&#39;m handwriting assembly, I generally choose the form

    lea eax, [eax+4]

Over the form..

    add eax, 4

I have heard that lea is a &quot;0-clock&quot; instruction (like NOP), while &#39;add&#39; isn&#39;t. However, when I look at compiler produced Assembly I often see the latter form used instead of the first. I&#39;m smart enough to trust the compiler, so can anyone shed some light on which one is better? Which one is faster? Why is the compiler choosing the latter form over the former?

LEA or ADD instruction?

A couple of questions regarding the x86 CPU privilege rings:

- Why aren&#39;t rings 1 and 2 used by most operating systems? Is it just to maintain code compatibility with other architectures, or is there a better reason?

- Are there any operating systems which actually use those rings? Or are they completely unused?

CPU Privilege Rings: Why rings 1 and 2 aren&#39;t used?

## Overview

I have an image buffer that I need to convert to another format.  The origin image buffer is four channels, 8 bits per channel, Alpha, Red, Green, and Blue.  The destination buffer is three channels, 8 bits per channel, Blue, Green, and Red.

So the brute force method is:

    // Assume a 32 x 32 pixel image
    #define IMAGESIZE (32*32)

    typedef struct{ UInt8 Alpha; UInt8 Red; UInt8 Green; UInt8 Blue; } ARGB;
    typedef struct{ UInt8 Blue; UInt8 Green; UInt8 Red; } BGR;

    ARGB orig[IMAGESIZE];
    BGR  dest[IMAGESIZE];

    for(x = 0; x &lt; IMAGESIZE; x++)
    {
         dest[x].Red = orig[x].Red;
         dest[x].Green = orig[x].Green;
         dest[x].Blue = orig[x].Blue;
    }

However, I need more speed than is provided by a loop and three byte copies. I&#39;m hoping there might be a few tricks I can use to reduce the number of memory reads and writes, given that I&#39;m running on a 32 bit machine.

## Additional info

Every image is a multiple of at least 4 pixels.  So we could address 16 ARGB bytes and move them into 12 RGB bytes per loop. Perhaps this fact can be used to speed things up, especially as it falls nicely into 32 bit boundaries.

I have access to OpenCL - and while that requires moving the entire buffer into the GPU memory, then moving the result back out, the fact that OpenCL can work on many portions of the image simultaneously, and the fact that large memory block moves are actually quite efficient may make this a worthwhile exploration.

While I&#39;ve given the example of small buffers above, I really am moving HD video (1920x1080) and sometimes larger, mostly smaller, buffers around, so while a 32x32 situation may be trivial, copying 8.3MB of image data byte by byte is really, really bad.

Running on Intel processors (Core 2 and above) and thus there are streaming and data processing commands I&#39;m aware exist, but don&#39;t know about - perhaps pointers on where to look for specialized data handling instructions would be good.

This is going into an OS X application, and I&#39;m using XCode 4.  If assembly is painless and the obvious way to go, I&#39;m fine traveling down that path, but not having done it on this setup before makes me wary of sinking too much time into it.

Pseudo-code is fine - I&#39;m not looking for a complete solution, just the algorithm and an explanation of any trickery that might not be immediately clear.

Content Type	Original Author	Original Content on Stackoverflow
Question	compile-fan	View Question on Stackoverflow
Solution 1 - Assembly	zneak	View Answer on Stackoverflow
Solution 2 - Assembly	Abhay Buch	View Answer on Stackoverflow
Solution 3 - Assembly	kabab	View Answer on Stackoverflow

Why does leave do "mov esp,ebp" in x86 assembly?

Assembly Problem Overview

Assembly Solutions

Solution 1 - Assembly

Solution 2 - Assembly

Solution 3 - Assembly

How to write a custom decorator in django?

Update row with data from another row in the same table

Attributions