Skip to content

This Repository is a collection of different ethical hacking tools and malware's for penetration testing and research purpose written in python, ruby, rust, c++, go and c.

Create Passing Parameters on the Stack.md

Abdul Wahab Junaidf3934a601dac
diff --git a/Assembly language/New Assembly Work/Assembly Language/Passing Parameters on the Stack.md b/Assembly language/New Assembly Work/Assembly Language/Passing Parameters on the Stack.md
new file mode 100644
index 0000000..9455cf0
--- /dev/null
+++ b/Assembly language/New Assembly Work/Assembly Language/Passing Parameters on the Stack.md
@@ -0,0 +1,69 @@
+**Passing parameters on the stack** is a common method of passing arguments to functions or procedures in assembly language and many programming languages. In this method, function arguments are pushed onto the stack before the function call, and the function retrieves these parameters from the stack during execution.
+
+### Key Concepts of Passing Parameters on the Stack
+
+1. **Stack Structure**: The stack is a data structure that follows the Last In, First Out (LIFO) principle. It grows downwards in memory, meaning that new entries are pushed to lower memory addresses.
+
+2. **Function Call Sequence**: When a function is called, the parameters are pushed onto the stack, and the function can access these parameters using a stack pointer or base pointer.
+
+3. **Cleanup Responsibility**: Depending on the calling convention, either the caller or the callee is responsible for cleaning up the stack after the function call. This affects how the stack is managed and how many bytes should be popped from the stack after the call.
+
+### Example: Passing Parameters on the Stack in HLA
+
+Here's an example demonstrating how to pass parameters using the stack in High-Level Assembly (HLA):
+
+```assembly
+program PassParametersOnStackExample;
+
+#include("stdlib.hhf")
+
+// Procedure that takes two integers as parameters
+procedure AddValues(a: int, b: int);
+begin AddValues;
+ stdout.put("Sum: ", a + b, nl); // Add the two values and print the result
+end AddValues;
+
+begin PassParametersOnStackExample;
+
+ // Declare two integer variables
+ variable x: int := 10;
+ variable y: int := 20;
+
+ stdout.put("Passing parameters on the stack...\n");
+
+ // Pushing parameters onto the stack before calling the procedure
+ push(y); // Push second parameter (b)
+ push(x); // Push first parameter (a)
+
+ // Call the AddValues procedure
+ AddValues(); // Parameters are now available on the stack
+
+ // Clean up the stack after the call
+ add(esp, 8); // Clean up the stack by removing 8 bytes (2 integers)
+
+end PassParametersOnStackExample;
+```
+
+### Explanation of the Example
+
+1. **Variable Declaration**: The program declares two integer variables, `x` and `y`, and initializes them to `10` and `20`, respectively.
+
+2. **Pushing Parameters onto the Stack**: Before calling the `AddValues` procedure, the parameters are pushed onto the stack. Note that the second parameter (`b`, which is `y`) is pushed first, followed by the first parameter (`a`, which is `x`). This is because the stack is LIFO, and the function retrieves the parameters in reverse order.
+
+3. **Calling the Procedure**: The `AddValues` procedure is called without any parameters since the parameters have already been pushed onto the stack.
+
+4. **Stack Cleanup**: After the function call, the stack is cleaned up by adjusting the stack pointer (e.g., `add(esp, 8)`) to remove the two parameters (each 4 bytes for 32-bit integers).
+
+### Advantages of Passing Parameters on the Stack
+
+- **Flexibility**: Allows for a variable number of parameters to be passed, as parameters can be pushed to the stack as needed.
+- **No Register Limitation**: Since parameters are stored in memory rather than registers, there’s no limit based on the number of registers available.
+
+### Disadvantages of Passing Parameters on the Stack
+
+- **Performance**: Accessing parameters on the stack can be slower than accessing them in registers due to the additional memory access overhead.
+- **Stack Management**: Requires careful management of the stack to ensure that parameters are correctly pushed and popped, which can introduce complexity.
+
+### Conclusion
+
+Passing parameters on the stack is a widely used technique in assembly language and many high-level languages for managing function arguments. It offers flexibility in terms of parameter count but requires careful stack management to ensure proper execution.