Getting Started with BASM: A Beginner’s Guide to Delphi Assembly

Mastering BASM (Borland Assembler / Built-in Assembler) is the gateway to unlocking maximum execution speed, low-level hardware control, and advanced reverse engineering inside the ⁠Delphi environment. Because writing inline assembly skips the safety nets of the Object Pascal compiler, debugging and refactoring BASM requires a precise, systematic approach to avoid memory corruption and hidden application crashes. 1. Advanced Debugging Strategies for BASM

Debugging assembly cannot be done using standard high-level variable watches alone. You must leverage Delphi’s dedicated low-level testing tools. Open the CPU Window

When your application hits a breakpoint inside an asm block, standard line-by-line debugging becomes insufficient. Press Ctrl + Alt + C to open the CPU View.

This window breaks your code into literal assembly instructions, memory addresses, and hex dumps.

It lets you see exactly how the registers change instruction by instruction as you press F8 (Step Over) or F7 (Step Into). Inject Hardware Breakpoints Programmatically

If you need to break execution based on a highly specific or fluctuating runtime condition, you can force the application directly into the CPU debugger by hardcoding an interrupt:

if (MyTargetRegisterValue = 0) then asm int 3; // Forces the Delphi IDE to pause right here end; Use code with caution. Monitor the Registers Window

You cannot type an assembly register (like EAX, RSI, or XMM0) directly into a standard variable Watch List. Instead, dock the Registers Window alongside your CPU view. Watch this panel closely to ensure you are not accidentally overwriting data or misaligning the stack. 2. Crucial Refactoring Guidelines for BASM

Refactoring BASM is not about making code look pretty with the IDE’s automated “Extract Method” tools; it is about ensuring architectural safety, portability, and calling convention obedience. Respect the Delphi Calling Conventions

When refactoring inline assembly into standalone functions, you must strictly obey how Delphi passes variables via the register calling convention.

In 32-bit Win32 (register): The first three parameters are passed via EAX, EDX, and ECX. Any remaining parameters are pushed onto the stack.

In 64-bit Win64 (msfastcall): The first four parameters are passed via RCX, RDX, R8, and R9 (or XMM0 through XMM3 for floating-point numbers).

Rule: If your refactored method changes its parameter order, you must manually update the internal register assignments inside your BASM block. Keep Volatile vs. Non-Volatile Registers Intact

A fast way to trigger unpredictable crashes (Access Violations) is failing to restore registers.

Volatile Registers: Registers like EAX/RAX, EDX/RDX, and ECX/RCX can be freely modified inside your assembly block.

Non-Volatile Registers: Registers like EBX/RBX, ESI/RSI, EDI/RDI, and EBP/RBP must be preserved. If you use them, you must save them to the stack at the start of your code (push rbx) and restore them before exiting (pop rbx). Handle 32-bit to 64-bit Portability

If you are refactoring legacy Delphi code to support modern 64-bit operating systems, remember that pointer sizes double from 4 bytes to 8 bytes.

Replace explicitly typed registers (like EAX or EDX) with generic pointer registers (RAX, RDX).

Utilize the built-in conditional compilation directives to cleanly separate your logic:

{\(IFDEF CPUI386} // 32-bit optimized BASM code {\)ENDIF} {\(IFDEF CPUX64} // 64-bit optimized BASM code {\)ENDIF} Use code with caution. The Ultimate Refactoring Strategy: Write Pure Pascal First

The gold standard of BASM refactoring is maintaining a Pure Pascal fallback. Write a secondary, completely readable Object Pascal version of the function. Use your BASM version strictly for production performance, but keep the Pascal function available for automated testing to verify that your assembly changes have not broken the application logic.

Are you working on optimizing a 32-bit or a 64-bit Delphi application, and what specific CPU instruction set (e.g., AVX, SSE, standard x86) are you targeting? Stack Overflow

Good Resources for using Assembly in Delphi? – Stack Overflow