Reverse Engineering Notes - C Language Calling Conventions and Syntax Overview

 

Calling Conventions

A calling convention is a set of rules that determine how parameters are passed to a function, how the return value is handled, and how the function is called. There are several different calling conventions used in C programming, but two of the most common are the cdecl and stdcall conventions.

cdecl Calling Convention

The cdecl calling convention is used by default in C programming. In this convention, the caller is responsible for cleaning up the stack after the function call. Parameters are pushed onto the stack in reverse order, with the rightmost parameter being pushed first. The return value is stored in the EAX register for 32-bit systems or in the RAX register for 64-bit systems.

Here is an example of using the cdecl calling convention:

c

int add_numbers(int x, int y);

int main() {
    int result = add_numbers(2, 3);
    return 0;
}

int add_numbers(int x, int y) {
    int sum = x + y;
    return sum;
}

In this example, the add_numbers() function takes two integer parameters and returns their sum. The main() function calls add_numbers() with the values 2 and 3 and stores the result in the result variable.

stdcall Calling Convention

The stdcall calling convention is used in some Windows API functions. In this convention, the callee is responsible for cleaning up the stack after the function call. Parameters are pushed onto the stack in right-to-left order, with the leftmost parameter being pushed first. The return value is stored in the EAX register for 32-bit systems or in the RAX register for 64-bit systems.

Here is an example of using the stdcall calling convention:

c

#include <windows.h>

int main() {
    MessageBox(NULL, "Hello, World!", "Message", MB_OK);
    return 0;
}

In this example, the MessageBox() function is called with the parameters NULL, "Hello, World!", "Message", and MB_OK. The function displays a message box with the specified text and returns an integer value indicating which button was clicked.

Programming Syntax

C programming syntax includes a variety of constructs for declaring variables, defining functions, and controlling program flow. Here are some examples of basic C programming syntax:

Variable Declaration

Variables can be declared using the following syntax:

c

type variable_name;

For example, to declare an integer variable named x, use the following code:

c

int x;

Function Definition

Functions can be defined using the following syntax:

c

return_type function_name(parameter_type parameter_name) {
    // function body
}

For example, to define a function named add_numbers() that takes two integer parameters and returns their sum, use the following code:

c

int add_numbers(int x, int y) {
    int sum = x + y;
    return sum;
}

Control Structures

C provides several control structures for controlling program flow, including if statements, for loops, and while loops. Here are some examples of control structures:

if Statement

c

if (condition) {
    // code to execute if condition is true
} else {
    // code to execute if condition is false
}

For example:

c

int x = 5;

if (x > 0) {
    printf("x is positive");
} else if (x < 0) {
    printf
 
Variables 

In C, there are several ways to initialize variables, including:

1. Initialization at declaration: This is the most common way to initialize a variable in C. You can declare a variable and initialize it with a value in a single line of code, like this:

   python

5. static int x; // automatically initialized to zero
   

   In this example, we declare a static integer variable "x" which is automatically initialized to zero.

These are some of the most common ways to initialize variables in C. By using these techniques, you can ensure that your variables are properly initialized before they are used in your program.

int x = 10;

In this example, we declare an integer variable "x" and initialize it with the value 10.

Initialization using assignment: You can also initialize a variable using the assignment operator "=" after it has been declared, like this:

python

int x;
x = 10;

In this example, we declare an integer variable "x" and assign the value 10 to it after it has been declared.

Initialization with a compound literal: A compound literal is an expression that creates an unnamed object with a specific type and value. You can use a compound literal to initialize a variable, like this:

python

int x = (int){10};

In this example, we use a compound literal to create an integer object with the value 10, and then assign that value to the variable "x".

Initialization with an initializer list: An initializer list is a comma-separated list of values enclosed in braces "{}". You can use an initializer list to initialize an array or struct, like this:

python

int arr[3] = {1, 2, 3};

In this example, we declare an integer array "arr" with three elements and initialize it with the values 1, 2, and 3.

Static initialization: In C, variables with static storage duration are automatically initialized to zero if no other initializer is specified.

Static Int

In C, the keyword "static" can be used to modify the storage class of a variable. When used with an int (or any other data type), "static int" creates a variable that is only visible within the function or file where it is declared, and retains its value between function calls.

Here are some key characteristics of a static int variable:

1. Scope: A static int variable is only visible within the function or file where it is declared. It cannot be accessed from outside that scope.

2. Lifetime: Unlike a normal (automatic) variable, which is created when the function is called and destroyed when the function returns, a static int variable is created when the program starts and persists throughout the program's lifetime. This means that its value is retained between function calls.

3. Initialization: A static int variable is initialized to zero by default. If it is explicitly initialized to another value, that value will be retained between function calls.

Here is an example of using a static int variable in a function:

c

#include <stdio.h>

void myFunction() {
    static int count = 0; // declare and initialize static variable
    
    count++; // increment the count
    
    printf("Count = %d\n", count); // print the current count
}

int main() {
    myFunction(); // prints "Count = 1"
    myFunction(); // prints "Count = 2"
    myFunction(); // prints "Count = 3"
    
    return 0;
}

In this example, the static int variable "count" is declared inside the "myFunction" function and initialized to zero. Each time the function is called, the value of "count" is incremented and printed to the console. Because "count" is a static variable, its value is retained between function calls, so the output will be "Count = 1", "Count = 2", and "Count = 3".