int square(int num, int num2,int num3,bool w,int num4) {
    return num * num;
}
    

square(int, int, int, bool, int):
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     DWORD PTR [rbp-8], esi
        mov     DWORD PTR [rbp-12], edx
        mov     eax, ecx
        mov     DWORD PTR [rbp-20], r8d
        mov     BYTE PTR [rbp-16], al
        mov     eax, DWORD PTR [rbp-4]
        imul    eax, eax
        pop     rbp
        ret  
    

        push    rbp
        mov     rbp, rsp
        sub      rsp, 20   // added by me
    

square:
  mov eax,edi
  imul eax,eax
  ret    

I am new to "red zone" concept.

The square function above can be greatly simplified.

Code:

square:
  mov eax,edi
  imul eax,eax
  ret    

I thought stack grows upward, until recently I saw an article saying it grows downward.

...I am wondering whether compiler's optimized code will match your simplified code?

FlierMate1 wrote:

...I am wondering whether compiler's optimized code will match your simplified code?

Try it. What do you get?

Not successful. I tried all the compiler options for optimization on "Compiler Explorer" but none give clean and simplified code like yours.

You win! Human 1 vs Machine 0

That should be easy for a compiler to do. Did you try -O3 or -Os?

square(int, int, int, bool, int):
        imul    edi, edi
        mov     eax, edi
        ret
    

Program:Square(int):int:
       mov      eax, edi
       imul     eax, edi
       ret  
    

#include <iostream>

int square(int num) {
    return num * num;
}

int main() {
    int sq;
    sq = square(5);
    std::cout << sq;
    return 0;
}    

square(int):
        imul    edi, edi
        mov     eax, edi
        ret
main:
        push    rax
        mov     esi, 25
        mov     edi, OFFSET FLAT:_ZSt4cout
        call    std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
        xor     eax, eax
        pop     rdx
        ret
_GLOBAL__sub_I_square(int):
        push    rax
        mov     edi, OFFSET FLAT:_ZStL8__ioinit
        call    std::ios_base::Init::Init() [complete object constructor]
        mov     edx, OFFSET FLAT:__dso_handle
        mov     esi, OFFSET FLAT:_ZStL8__ioinit
        pop     rcx
        mov     edi, OFFSET FLAT:_ZNSt8ios_base4InitD1Ev
        jmp     __cxa_atexit    

using System;

class Program
{
    static int Square(int num) => num * num;

    static void Main(string[] args){
        Console.WriteLine(Square(8));
    }
}    

Program:.ctor():this:
       ret      

Program:Main(System.String[]):
       push     rax
       mov      edi, 64
       call     [System.Console:WriteLine(int)]
       nop      
       add      rsp, 8
       ret      

Program:Square(int):int:
       mov      eax, edi
       imul     eax, edi
       ret      
    

He counted the result as 25, but left the square code for some reason.

CompilerExplorer.Program:Main():
       push     rbp
       sub      rsp, 16
       lea      rbp, [rsp+10H]
       xor      eax, eax
       mov      qword ptr [rbp-10H], rax
       mov      edi, 8
       call     [CompilerExplorer.Program:Square(int):int]
       mov      dword ptr [rbp-04H], eax
       xor      edi, edi
       call     [CORINFO_HELP_READYTORUN_NEWARR_1]
       mov      gword ptr [rbp-10H], rax
       mov      edi, dword ptr [rbp-04H]
       mov      rsi, gword ptr [rbp-10H]
       call     [Microsoft.VisualBasic.FileSystem:Print(int,System.Object[])]
       nop      
       add      rsp, 16
       pop      rbp
       ret      

CompilerExplorer.Program:Square(int):int:
       push     rax
       mov      eax, edi
       imul     eax, edi
       jo       SHORT G_M28424_IG04
       add      rsp, 8
       ret      
G_M28424_IG04:
       call     [CORINFO_HELP_OVERFLOW]
       int3         

Module Program
    Function Square(num As Integer) As Integer
        Return num * num
    End Function

    sub Main()
        Print (Square(8))
    end sub
End Module    

mov      qword [rbp-10H], rax ;ignore ptr 
mov      edi, dword  [rbp-04H]
mov      rsi, qword [rbp-10H]
    

QWORD

Code:

mov      qword [rbp-10H], rax ;ignore ptr 
mov      edi, dword  [rbp-04H]
mov      rsi, qword [rbp-10H]
    

dkm commented 18 seconds ago
If you're correct, then it's a bug in the compiler, not compiler explorer. There's nothing we can do about that...

It's not a bug, they have several references to gword in their code and they have a couple of other weird ones https://github.com/dotnet/runtime/blob/11f24dd3b68da68dbbbd222dac98768f6893f30c/src/coreclr/jit/instr.cpp#L199
It seems to be a EA_GCREF, whatever that means

    unsigned size = EA_SIZE(attr);

    assert(size == 0 || size == 1 || size == 2 || size == 4 || size == 8 || size == 16 || size == 32);

    if (EA_ATTR(size) == attr)
    {
        return sizes[size];
    }
    else if (attr == EA_GCREF)
    {
        return "gword ptr ";
    }
    else if (attr == EA_BYREF)
    {
        return "bword ptr ";
    }
    else if (EA_IS_DSP_RELOC(attr))
    {
        return "rword ptr ";
    }
    else
    {
        assert(!"Unexpected");
        return "unknw ptr ";
    }
}