Learning assembly language can seem daunting, but it’s a rewarding journey into the heart of computer programming. On LEARNS.EDU.VN, we’ll guide you through the process, making it accessible and engaging. This guide will provide a comprehensive overview of assembly language, its uses, and how you can effectively learn it, turning a complex topic into an achievable goal.
1. What Is Assembly Language and Why Learn It?
Assembly language is a low-level programming language that’s closely related to machine code, the language that a computer’s central processing unit (CPU) directly understands. Instead of using binary code (0s and 1s), assembly language uses mnemonics, which are short abbreviations that represent specific machine instructions.
1.1. Understanding the Basics of Assembly Language
Assembly language acts as an intermediary between human-readable code and machine code. Each assembly instruction typically corresponds to a single machine instruction. This direct correspondence allows programmers to have fine-grained control over the hardware, making it useful in scenarios where performance and resource management are critical.
1.2. Key Reasons to Learn Assembly Language
- Deeper Understanding of Computer Architecture: Learning assembly language provides insights into how CPUs work, how memory is managed, and how software interacts with hardware.
- Performance Optimization: Assembly allows for precise control over CPU instructions, which can lead to highly optimized code for specific tasks.
- Reverse Engineering: Understanding assembly is crucial for reverse engineering software, analyzing malware, and identifying vulnerabilities.
- Embedded Systems Programming: Assembly language is often used in embedded systems where resources are limited and direct hardware control is necessary.
- Compiler Design: Assembly can aid in compiler design and understanding how high-level languages are translated into machine code.
- Debugging: Assembly-level debugging can help identify and fix issues that are difficult to detect at higher levels of abstraction.
2. Who Should Learn Assembly Language?
Assembly language isn’t for everyone, but certain individuals and professionals can benefit greatly from learning it.
2.1. Ideal Candidates for Assembly Language Learning
- Computer Science Students: Students studying computer science can gain a deeper understanding of how computers operate at a fundamental level.
- Software Developers: Developers can use assembly to optimize critical sections of code or to understand how compilers translate high-level code into machine instructions.
- Reverse Engineers: Professionals in cybersecurity and reverse engineering rely on assembly to analyze software, identify vulnerabilities, and understand how malware operates.
- Embedded Systems Engineers: Engineers working on embedded systems often use assembly to directly control hardware and optimize code for resource-constrained environments.
- Operating System Developers: Understanding assembly is crucial for developing and debugging operating systems.
2.2. Addressing the Needs of Different Age Groups
- Students (10-18): While assembly might be advanced, introducing basic concepts can spark interest in computer architecture and low-level programming.
- University Students (18-24): Assembly language is highly relevant for coursework in computer architecture, systems programming, and reverse engineering.
- Professionals (24-65+): Assembly language can enhance skills in performance optimization, embedded systems, and cybersecurity.
3. Setting the Stage: Prerequisites and Mindset
Before diving into assembly language, it’s helpful to have a foundation in certain areas.
3.1. Essential Prerequisites
- Basic Programming Knowledge: Familiarity with programming concepts like variables, loops, and conditional statements is essential.
- Understanding of Computer Architecture: Basic knowledge of how computers work, including CPUs, memory, and input/output devices, is helpful.
- Number Systems: Understanding binary, hexadecimal, and decimal number systems is crucial since assembly deals directly with machine-level representations.
- Operating System Concepts: Familiarity with operating system concepts like memory management and processes is beneficial.
3.2. Cultivating the Right Mindset
- Patience: Learning assembly language takes time and effort. Be patient and persistent.
- Detail-Oriented: Assembly requires attention to detail, as even small errors can lead to significant issues.
- Problem-Solving Skills: Assembly programming involves solving complex problems, so strong analytical and problem-solving skills are necessary.
- Curiosity: A willingness to explore and experiment is essential for mastering assembly language.
4. Choosing an Assembly Language and Platform
Different CPUs have different assembly languages. Here are some popular choices and platforms to consider.
4.1. Popular Assembly Languages
- x86-64 Assembly: Used in most modern desktop and laptop computers. It’s the most widely used assembly language due to the prevalence of x86-64 processors.
- ARM Assembly: Used in mobile devices, embedded systems, and some servers. ARM processors are known for their energy efficiency, making them popular in battery-powered devices.
- MIPS Assembly: Used in embedded systems and teaching environments. MIPS is often used in educational settings to teach computer architecture concepts.
- RISC-V Assembly: An open-source ISA (Instruction Set Architecture) gaining popularity in research and custom hardware. RISC-V’s open nature makes it attractive for custom hardware designs and academic research.
4.2. Selecting a Platform
- Windows: Use tools like MASM (Microsoft Macro Assembler) or FASM (Flat Assembler). Windows is a popular choice due to its wide user base and extensive development tools.
- Linux: Use GAS (GNU Assembler) or NASM (Netwide Assembler). Linux offers powerful command-line tools and a robust development environment.
- macOS: Use GAS (GNU Assembler) or NASM (Netwide Assembler). macOS provides a Unix-like environment that is well-suited for assembly development.
- Embedded Systems: Use the toolchain provided by the microcontroller manufacturer. Embedded systems often require specialized tools for programming and debugging.
5. Setting Up Your Development Environment
To start writing assembly code, you’ll need an assembler, a linker, and a debugger.
5.1. Essential Tools for Assembly Development
- Assembler: Converts assembly code into machine code. Popular assemblers include MASM, GAS, NASM, and FASM.
- Linker: Combines object files produced by the assembler into an executable program. Common linkers include the GNU Linker (ld) and the Microsoft Linker (link.exe).
- Debugger: Helps you find and fix errors in your code. Useful debuggers include GDB (GNU Debugger) and WinDbg.
- Text Editor: For writing assembly code. Choose one with syntax highlighting for assembly language.
- Operating System: Choose the OS you want to develop for (Windows, Linux, macOS, etc.).
5.2. Step-by-Step Setup Guide
- Install an Assembler:
- Windows (MASM): Download and install the Windows SDK, which includes MASM.
- Linux/macOS (GAS): GAS is typically included with the GCC (GNU Compiler Collection). Make sure GCC is installed.
- NASM: Download NASM from the official website and install it.
- Install a Linker:
- Windows: The Microsoft Linker comes with Visual Studio or the Windows SDK.
- Linux/macOS: The GNU Linker (ld) is usually included with GCC.
- Install a Debugger:
- Windows: Download and install WinDbg from the Microsoft Store or the Windows SDK.
- Linux/macOS: GDB is usually included with GCC.
- Choose a Text Editor:
- Popular choices include Visual Studio Code, Sublime Text, and Atom. Install an assembly language syntax highlighting extension.
- Set Up Environment Variables:
- Add the paths to the assembler, linker, and debugger to your system’s environment variables.
6. Core Concepts of Assembly Language
Understanding the fundamental concepts is key to writing effective assembly code.
6.1. Registers
Registers are small, high-speed storage locations within the CPU used to hold data and instructions.
- General-Purpose Registers: Used for arithmetic, logical operations, and memory addressing. Examples include
EAX,EBX,ECX,EDX(x86) andR0–R12(ARM). - Segment Registers: Used to manage memory segments (mostly obsolete in modern systems). Examples include
CS,DS,SS,ES,FS,GS(x86). - Instruction Pointer: Holds the address of the next instruction to be executed.
EIP(x86) andPC(ARM). - Stack Pointer: Points to the top of the stack.
ESP(x86) andSP(ARM). - Flag Register: Contains status flags that reflect the results of arithmetic and logical operations.
EFLAGS(x86) andCPSR(ARM).
6.2. Memory Addressing
Memory addressing is how assembly code accesses data stored in memory.
- Direct Addressing: Accessing memory locations directly using their addresses.
- Indirect Addressing: Accessing memory locations through a pointer stored in a register.
- Indexed Addressing: Accessing memory locations by adding an offset to a base address stored in a register.
- Base-Pointer Addressing: Accessing memory locations by adding an offset to a base pointer register.
6.3. Instructions
Instructions are the basic commands that the CPU can execute.
- Data Transfer Instructions: Move data between registers and memory. Examples include
MOV,PUSH,POP(x86) andLDR,STR(ARM). - Arithmetic Instructions: Perform arithmetic operations. Examples include
ADD,SUB,MUL,DIV(x86 and ARM). - Logical Instructions: Perform logical operations. Examples include
AND,OR,XOR,NOT(x86 and ARM). - Control Flow Instructions: Control the flow of execution. Examples include
JMP,JE,JNE,CALL,RET(x86) andB,BEQ,BNE,BL,BX(ARM).
6.4. The Stack
The stack is a region of memory used for temporary storage, function calls, and local variables.
- Push: Adds data to the top of the stack.
- Pop: Removes data from the top of the stack.
- Stack Frame: A section of the stack allocated for a function call, containing arguments, return address, and local variables.
6.5. Calling Conventions
Calling conventions are rules that define how functions pass arguments, return values, and manage the stack.
- cdecl: Arguments are passed on the stack, and the caller is responsible for cleaning up the stack.
- stdcall: Arguments are passed on the stack, and the callee is responsible for cleaning up the stack.
- fastcall: Arguments are passed in registers, and the callee may be responsible for cleaning up the stack.
- System V AMD64 ABI: Used on Linux and macOS for x86-64. Arguments are passed in registers (RDI, RSI, RDX, RCX, R8, R9) and on the stack.
7. Writing Your First Assembly Program
Let’s create a simple “Hello, World!” program to get started.
7.1. A Simple “Hello, World!” Example (x86-64, Linux)
section .data
msg db "Hello, World!", 10 ; The message to print (10 is newline)
len equ $ - msg ; Length of the message
section .text
global _start ; Entry point for the linker
_start:
; Write to stdout
mov rax, 1 ; syscall number for write
mov rdi, 1 ; file descriptor 1 is stdout
mov rsi, msg ; address of string to output
mov rdx, len ; number of bytes to write
syscall ; invoke operating system to do the write
; Exit the program
mov rax, 60 ; syscall number for exit
xor rdi, rdi ; exit code 0
syscall ; invoke operating system to exit7.2. Explanation of the Code
.section .data: Defines a data section where the message to be printed is stored.msg db "Hello, World!", 10: Defines the string “Hello, World!” followed by a newline character (10).len equ $ - msg: Calculates the length of the message..section .text: Defines the text section where the executable code is stored.global _start: Declares the entry point of the program._start: The label for the entry point.mov rax, 1: Sets theraxregister to 1, which is the system call number for writing to stdout on Linux.mov rdi, 1: Sets therdiregister to 1, which is the file descriptor for stdout.mov rsi, msg: Sets thersiregister to the address of the message string.mov rdx, len: Sets therdxregister to the length of the message.syscall: Invokes the operating system to perform the write operation.mov rax, 60: Sets theraxregister to 60, which is the system call number for exiting the program on Linux.xor rdi, rdi: Sets therdiregister to 0, which is the exit code.syscall: Invokes the operating system to exit the program.
7.3. Assembling and Running the Code
-
Save the code in a file named
hello.asm. -
Assemble the code using NASM:
nasm -f elf64 hello.asm -o hello.o -
Link the code using the GNU linker:
ld hello.o -o hello -
Run the program:
./hello
8. Essential Assembly Instructions and Their Uses
Mastering key instructions is crucial for effective assembly programming.
8.1. Data Transfer Instructions
| Instruction | Description | Example |
|---|---|---|
| MOV | Move data from one location to another | MOV EAX, EBX |
| PUSH | Push data onto the stack | PUSH EAX |
| POP | Pop data from the stack | POP EAX |
| LEA | Load effective address (calculate the address and store it in a register) | LEA EAX, [EBX+4] |
8.2. Arithmetic Instructions
| Instruction | Description | Example |
|---|---|---|
| ADD | Add two operands | ADD EAX, EBX |
| SUB | Subtract one operand from another | SUB EAX, EBX |
| MUL | Multiply two operands | MUL EBX |
| DIV | Divide one operand by another | DIV EBX |
| INC | Increment an operand | INC EAX |
| DEC | Decrement an operand | DEC EAX |
8.3. Logical Instructions
| Instruction | Description | Example |
|---|---|---|
| AND | Perform a bitwise AND operation | AND EAX, EBX |
| OR | Perform a bitwise OR operation | OR EAX, EBX |
| XOR | Perform a bitwise XOR operation | XOR EAX, EBX |
| NOT | Perform a bitwise NOT operation | NOT EAX |
8.4. Control Flow Instructions
| Instruction | Description | Example |
|---|---|---|
| JMP | Jump to a specified address | JMP label |
| JE/JZ | Jump if equal/jump if zero | JE label |
| JNE/JNZ | Jump if not equal/jump if not zero | JNE label |
| JG/JNLE | Jump if greater/jump if not less or equal | JG label |
| JL/JNGE | Jump if less/jump if not greater or equal | JL label |
| CALL | Call a subroutine | CALL subroutine |
| RET | Return from a subroutine | RET |
| CMP | Compare two operands (sets flags for conditional jumps) | CMP EAX, EBX |
| TEST | Perform a bitwise AND to set flags | TEST EAX, EAX |
9. Working with System Calls
System calls allow assembly programs to interact with the operating system.
9.1. What Are System Calls?
System calls are requests made by a program to the operating system kernel to perform tasks such as reading from a file, writing to the screen, or allocating memory.
9.2. Making System Calls (Linux x86-64)
On Linux x86-64, system calls are made using the syscall instruction. The system call number is placed in the rax register, and arguments are passed in registers rdi, rsi, rdx, r10, r8, and r9.
; Example: Writing to stdout
mov rax, 1 ; syscall number for write
mov rdi, 1 ; file descriptor 1 is stdout
mov rsi, msg ; address of string to output
mov rdx, len ; number of bytes to write
syscall ; invoke operating system to do the write9.3. Common System Calls
| System Call Number | Function | Description |
|---|---|---|
| 1 | write | Write data to a file descriptor |
| 60 | exit | Terminate the current process |
| 9 | mmap | Map files or devices into memory |
| 10 | munmap | Unmap files or devices from memory |
| 2 | open | Open a file |
| 3 | close | Close a file descriptor |
| 0 | read | Read data from a file descriptor |
10. Debugging Assembly Code
Debugging is an essential skill for assembly programmers.
10.1. Using Debuggers
- GDB (GNU Debugger): A powerful command-line debugger available on Linux and macOS.
- WinDbg: A debugger for Windows, offering both command-line and GUI interfaces.
10.2. Debugging Techniques
- Setting Breakpoints: Pause execution at specific instructions to examine the program’s state.
- Single Stepping: Execute one instruction at a time to follow the program’s flow.
- Inspecting Registers: View the contents of registers to see how data is being manipulated.
- Examining Memory: View the contents of memory to see how data is being stored.
- Using Logging: Insert instructions to print values to the console for debugging purposes.
10.3. Common Assembly Errors
- Segmentation Faults: Occur when the program tries to access memory it doesn’t have permission to access.
- Incorrect Memory Addressing: Using the wrong address or offset to access memory.
- Stack Overflow: Pushing too much data onto the stack, causing it to overwrite other memory areas.
- Misaligned Data: Accessing data at addresses that are not properly aligned for the data type.
11. Advanced Topics in Assembly Language
Once you have a solid grasp of the basics, you can explore more advanced topics.
11.1. Macros
Macros are reusable code snippets that can be expanded by the assembler.
%macro print 2 ; Define a macro named 'print' with 2 arguments
mov rax, 1 ; syscall number for write
mov rdi, 1 ; file descriptor 1 is stdout
mov rsi, %1 ; address of string to output
mov rdx, %2 ; number of bytes to write
syscall ; invoke operating system to do the write
%endmacro
section .data
msg db "Hello, World!", 10
len equ $ - msg
section .text
global _start
_start:
print msg, len ; Use the 'print' macro
mov rax, 60 ; syscall number for exit
xor rdi, rdi ; exit code 0
syscall ; invoke operating system to exit11.2. Assembly and High-Level Languages
- Inline Assembly: Embedding assembly code within high-level languages like C or C++.
- Interfacing Assembly with C/C++: Calling assembly functions from C/C++ and vice versa.
11.3. Optimization Techniques
- Loop Unrolling: Reducing loop overhead by duplicating the loop body.
- Instruction Scheduling: Rearranging instructions to avoid pipeline stalls.
- Using SIMD Instructions: Performing parallel operations on multiple data elements.
11.4. Security Considerations
- Buffer Overflows: Writing beyond the bounds of a buffer, potentially overwriting adjacent memory areas.
- Code Injection: Injecting malicious code into a program’s memory and executing it.
- Return-Oriented Programming (ROP): Constructing malicious code by chaining together existing code snippets.
12. Resources for Learning Assembly Language
There are many resources available to help you learn assembly language.
12.1. Online Tutorials and Courses
- LEARNS.EDU.VN: Offers comprehensive tutorials and courses on assembly language and computer architecture.
- Assembly Language Step-by-Step: A tutorial series covering x86 assembly.
- NAND to Tetris: A course that teaches you how to build a computer from scratch, including writing an assembler.
- Online Assembly Simulators: Websites like easy68k.com for practicing assembly without installing software.
12.2. Books
- Assembly Language for x86 Processors by Kip Irvine: A comprehensive guide to x86 assembly language.
- Programming from the Ground Up by Jonathan Bartlett: An introductory book on assembly language programming.
- Understanding the Machine by Steve Grand: A book that teaches assembly language by building a virtual machine.
12.3. Communities and Forums
- Stack Overflow: A question-and-answer website for programmers.
- Reddit: Subreddits like r/asm and r/lowlevelprogramming.
- Assembly Language Forums: Online forums dedicated to assembly language programming.
12.4. Documentation
- Intel Architecture Manuals: Detailed documentation on Intel x86 processors.
- ARM Architecture Reference Manuals: Detailed documentation on ARM processors.
- Assembler Manuals: Documentation for your chosen assembler (MASM, GAS, NASM, etc.).
13. Practical Projects to Enhance Your Skills
Working on practical projects is a great way to reinforce your knowledge and develop your skills.
13.1. Project Ideas
- Simple Calculator: Create a command-line calculator that performs basic arithmetic operations.
- Text Editor: Develop a simple text editor with basic editing features.
- Operating System Kernel: Write a basic operating system kernel with memory management and process scheduling.
- Emulator: Create an emulator for a simple CPU architecture.
- Game: Develop a simple game, such as a text-based adventure or a simple arcade game.
13.2. Step-by-Step Project: Creating a Simple Calculator
-
Plan the Project:
- Define the features of the calculator (addition, subtraction, multiplication, division).
- Design the user interface (command-line based).
- Plan the program structure (input, processing, output).
-
Set Up the Development Environment:
- Create a new assembly file (
calculator.asm). - Choose an assembler (NASM, GAS, MASM).
- Set up the necessary environment variables.
- Create a new assembly file (
-
Write the Code:
- Implement the input routine to read numbers and operators from the user.
- Implement the arithmetic routines (addition, subtraction, multiplication, division).
- Implement the output routine to display the results to the user.
- Implement the main program loop to continuously perform calculations until the user quits.
-
Assemble and Link the Code:
nasm -f elf64 calculator.asm -o calculator.o ld calculator.o -o calculator -
Test and Debug the Code:
- Test the calculator with various inputs to ensure it performs calculations correctly.
- Use a debugger (GDB, WinDbg) to identify and fix any errors.
-
Optimize the Code:
- Look for ways to improve the calculator’s performance, such as using more efficient algorithms or optimizing the assembly code.
14. The Future of Assembly Language
While high-level languages dominate modern software development, assembly language still has a role to play.
14.1. Current Uses of Assembly Language
- Embedded Systems: Assembly is still used in embedded systems where direct hardware control and performance are critical.
- Operating Systems: Operating system kernels and device drivers often contain assembly code for low-level hardware access.
- Reverse Engineering: Assembly is essential for reverse engineering software and analyzing malware.
- Security Research: Assembly is used in security research to identify vulnerabilities and develop exploits.
- Compiler Design: Assembly is used in compiler design to generate efficient machine code.
14.2. Trends in Assembly Language
- Rise of RISC-V: The open-source RISC-V ISA is gaining popularity, leading to increased interest in RISC-V assembly.
- Increased Use of SIMD: SIMD (Single Instruction, Multiple Data) instructions are becoming more important for performance optimization, leading to increased use of assembly for SIMD programming.
- Focus on Security: Assembly language is playing a key role in security research and vulnerability analysis.
14.3. Assembly Language in Modern Computing
Despite the rise of high-level languages, assembly language remains relevant in specific niches where performance, security, and hardware control are paramount. Understanding assembly can provide valuable insights into how computers work and how software interacts with hardware.
15. FAQs About Learning Assembly Language
Here are some frequently asked questions about learning assembly language.
15.1. Is Assembly Language Difficult to Learn?
Assembly language can be challenging due to its low-level nature and the need to understand computer architecture concepts. However, with patience, practice, and the right resources, it is definitely learnable.
15.2. How Long Does It Take to Learn Assembly Language?
The time it takes to learn assembly language depends on your background, learning style, and the amount of time you dedicate to it. A basic understanding can be achieved in a few weeks, while mastering it may take several months or years.
15.3. What Are the Best Resources for Learning Assembly Language?
- Online tutorials and courses
- Books
- Communities and forums
- Assembler and processor documentation
15.4. What Are the Career Opportunities for Assembly Programmers?
- Embedded Systems Engineer
- Operating System Developer
- Reverse Engineer
- Security Researcher
- Compiler Designer
15.5. Do I Need a Strong Math Background to Learn Assembly Language?
While a strong math background is not essential, it can be helpful for understanding certain concepts, such as floating-point arithmetic and digital signal processing.
15.6. Can I Learn Assembly Language on My Own?
Yes, you can learn assembly language on your own using online resources, books, and practice.
15.7. Is Assembly Language Still Relevant Today?
Yes, assembly language is still relevant in specific domains such as embedded systems, operating systems, reverse engineering, and security research.
15.8. Which Assembly Language Should I Learn First?
x86-64 assembly is a good starting point due to its prevalence in desktop and laptop computers.
15.9. What Is the Difference Between Assembly Language and Machine Code?
Assembly language is a human-readable representation of machine code. Machine code consists of binary instructions that the CPU can directly execute.
15.10. How Can I Practice Assembly Language Programming?
- Write simple programs
- Work on practical projects
- Participate in online coding challenges
- Contribute to open-source projects
16. Conclusion: Embark on Your Assembly Language Journey
Learning assembly language is a challenging but rewarding experience that can deepen your understanding of computer architecture and programming. By following this comprehensive guide, you can take your first steps toward mastering assembly language and unlocking its potential.
16.1. Final Thoughts and Encouragement
Don’t be discouraged by the complexity of assembly language. Start with the basics, practice regularly, and seek help from online resources and communities. With dedication and perseverance, you can achieve your goals and become proficient in assembly language programming.
16.2. Explore More at LEARNS.EDU.VN
Ready to dive deeper into the world of assembly language? Visit LEARNS.EDU.VN to discover more tutorials, courses, and resources that will help you on your learning journey. Explore our extensive collection of educational materials and join a community of passionate learners.
16.3. Call to Action
Unlock your potential and start learning assembly language today. Visit LEARNS.EDU.VN to find the resources and support you need to succeed. Whether you’re a student, a developer, or a cybersecurity professional, assembly language can enhance your skills and open up new opportunities. Don’t wait – begin your journey now!
For more information, contact us at:
Address: 123 Education Way, Learnville, CA 90210, United States
Whatsapp: +1 555-555-1212
Website: learns.edu.vn
format PE64 NX GUI 6.0
entry start
section '.text' code readable executable
start:
int3
ret section '.idata' import readable writeable
idt: ; import directory table starts here
; entry for KERNEL32.DLL
dd rva kernel32_iat
dd 0
dd 0
dd rva kernel32_name
dd rva kernel32_iat
; NULL entry - end of IDT
dd 5 dup(0)
name_table: ; hint/name table
_ExitProcess_Name dw 0
db "ExitProcess", 0, 0
kernel32_name db "KERNEL32.DLL", 0
kernel32_iat: ; import address table for KERNEL32.DLL
ExitProcess dq rva _ExitProcess_Name
dq 0 ; end of KERNEL32's IAT format PE64 NX GUI 6.0
entry start
section '.text' code readable executable
start:
int3
sub rsp, 8 * 5 ; adjust stack ptr and allocate shadow space.
xor rcx, rcx ; The first and only argument is the return code - passed in rcx.
call [ExitProcess]
section '.idata' import readable writeable
idt: ; import directory table starts here
; entry for KERNEL32.DLL
dd rva kernel32_iat
dd 0
dd 0
dd rva kernel32_name
dd rva kernel32_iat
; NULL entry - end of IDT
dd 5 dup(0)
name_table: ; hint/name table
_ExitProcess_Name dw 0
db "ExitProcess", 0, 0
kernel32_name db "KERNEL32.DLL", 0
kernel32_iat: ; import address table for KERNEL32.DLL
ExitProcess dq rva _ExitProcess_Name
dq 0 ; end of KERNEL32's IAT
