calling-convention

I don't see any comment in the standard except linkage related things. Though the standard doesn't say anything about calling convention, the calling conventions might be different between C and C++ in the real world, so I expected that the types of a C function and a C++ function are different. But it seems not, especially in GCC. #include <type_traits> extern "C" { int c_func(int); } int cpp_func(int); static_assert(!std::is_same<decltype(c_func), decltype(cpp_func)>::value, "It should not be the same type"); static_assert fails since GCC considers those functions have the same type. Is

I want to know how objective C runtime handle arguments when I call a objective C method like [NSString stringWithFomat:@"%@, %@", @"Hello", @"World"] There are three arguments for this objective C call, how does it work compared to typical way on a ARM system. I have known register r0, r1, r2, r3 will hold first 4 arguments, how about there are additional arguments? How does it put them on a stack and pop them later? For functions that returns a simple type: r0 = self (NSString) r1 = _cmd (@selector(stringWithFormat:)) r2 = 1st argument (@"%@, %@") r3 = 2nd argument (@"Hello") then the rest

I am trying to make sense out of the executable code that GCC (4.4.3) is generating for an x86_64 machine running under Ubuntu Linux. In particular, I don't understand how the code keeps track of stack frames. In the old days, in 32-bit code, I was accustomed to seeing this "prologue" in just about every function: push %ebp movl %esp, %ebp Then, at the end of the function, there would come an "epilogue," either sub $xx, %esp # Where xx is a number based on GCC's accounting. pop %ebp ret or simply leave ret which accomplishes the same thing: Set the Stack Pointer to the top of the current frame

It seems state-of-art compilers treat arguments passed by stack as read-only. Note that in the x86 calling convention, the caller pushes arguments onto the stack and the callee uses the arguments in the stack. For example, the following C code: extern int goo(int *x); int foo(int x, int y) { goo(&x); return x; } is compiled by clang -O3 -c g.c -S -m32 in OS X 10.10 into: .section __TEXT,__text,regular,pure_instructions .macosx_version_min 10, 10 .globl _foo .align 4, 0x90 _foo: ## @foo ## BB#0: pushl %ebp movl %esp, %ebp subl $8, %esp movl 8(%ebp), %eax movl %eax, -4(%ebp) leal -4(%ebp), %eax

Say I have this function: int func2() { printf("func2\n"); return 0; } Now I declare a pointer: int (*fp)(double); This should point to a function that takes a double argument and returns an int . func2 does NOT have any argument, but still when I write: fp = func2; fp(2); (with 2 being just an arbitrary number), func2` is invoked correctly. Why is that? Is there no meaning to the number of parameters I declare for a function pointer? Yes, there is a meaning. In C (but not in C++), a function declared with an empty set of parentheses means it takes an unspecified number of parameters. When you

Im very new to assembly but know a bit of c. Im playing around with extern function calls like extern _printf str db "Hello", 0 push str call _printf but cant find any tutorials using extern functions except scanf and printf. For example strcmp? How can i call strcmp in my case? Micrified Here is my answer. It is specific to x86-64 though. Please know that when pushing arguments to a function, you usually place the first 6 in registers rdi , rsi , rdx , rcx , r8 , and r9 . The rest get pushed to the stack. The specification for this is called the System V ABI (Note that Windows uses a