calling-convention

I know that Scala supports call-by-name from ALGOL, and I think I understand what that means, but can Scala do call-by-reference like C#, VB.NET, and C++ can? I know that Java cannot do call-by-reference, but I'm unsure if this limitation is solely due to the language or also the JVM. This would be useful when you want to pass an enormous data structure to a method, but you don't want to make a copy of it. Call-by-reference seems perfect in this case. Java and Scala both use call by value exclusively, except that the value is either a primitive or a pointer to an object. If your object

Consider this code: #include <utility> #include <tuple> std::pair<int, int> f1() { return std::make_pair(0x111, 0x222); } std::tuple<int, int> f2() { return std::make_tuple(0x111, 0x222); } Clang 3 and 4 generate similar code for both on x86-64: f1(): movabs rax,0x22200000111 ret f2(): movabs rax,0x11100000222 ; opposite packing order, not important ret But Clang 5 generates different code for f2() : f2(): movabs rax,0x11100000222 mov QWORD PTR [rdi],rax mov rax,rdi ret As do GCC 4 through GCC 7: f2(): movabs rdx,0x11100000222 mov rax,rdi mov QWORD PTR [rdi],rdx ; GCC 4-6 use 2 DWORD stores

I've come across __stdcall a lot these days. MSDN doesn't explain very clearly what it really means, when and why should it be used, if at all. I would appreciate if someone would provide an explanation, preferably with an example or two. JaredPar All functions in C/C++ have a particular calling convention. The point of a calling convention is to establish how data is passed between the caller and callee and who is responsible for operations such as cleaning out the call stack. The most popular calling conventions on windows are __stdcall , Pushes parameters on the stack, in reverse order

I'm trying to get a deeper understanding of how the low level operations of programming languages work and especially how they interact with the OS/CPU. I've probably read every answer in every stack/heap related thread here on Stack Overflow, and they are all brilliant. But there is still one thing that I didn't fully understand yet. Consider this function in pseudo code which tends to be valid Rust code ;-) fn foo() { let a = 1; let b = 2; let c = 3; let d = 4; // line X doSomething(a, b); doAnotherThing(c, d); } This is how I assume the stack to look like on line X: Stack a +-------------+

The common calling conventions for IA-32 say: • Callee-save registers %ebx, %esi, %edi, %ebp, %esp Callee must not change these. (Or restore the caller's values before returning.) • Caller-save registers %eax, %edx, %ecx, condition flags Caller saves these if it wants to preserve them. Callee can freely clobber. Why does this strange convention exist? Why not save all the registers before calling another function? Or have the callee save and restore everything with pusha / popa ? Why would you want to write code to save registers in every function that you might not need? That would add extra

I was researching the calling convention of x86_64 that's used on OSX and was reading the section called "Aggregates and Unions" in the System V x86-64 ABI standard ). It mention arrays and I figured that was like a fixed length c array, e.g. int[5] . I went down to "3.2.3 Parameter Passing" to read about how arrays were passed and if I'm understanding correctly, something like uint8_t[3] should be passed in registers as it's smaller than the four eightbyte limit imposed by rule 1 of the classification of aggregate types (page 18 near the bottom). After compiling I see that instead it's being

On x64, does each PUSH instruction push a multiple of 8 bytes? If not, how much does it push? Also, how much stack space does each function parameter consume? No, but in practice, one always pushes an 8 byte value onto the stack. Function parameters consuming varying amounts of stack space depending on the size of the function parameter and whether it is passed in the stack, in the registers, or passed by reference. If one passes a function parameter in the stack by pushing , then the fact that there are convenient push instructions that pushes 8 bytes strongly suggests that you pass the