Lenguaje de Ensamblador x86-64 (64 bits)
```asm ; 64-bit register usage examples mov rax, 0123456789ABCDEFh ; Load 64-bit immediate value mov r8, rax ; Copy to new register R8 mov r9d, eax ; 32-bit operation clears upper 32 bits mov r10w, ax ; 16-bit operation preserves upper bits mov r11b, al ; 8-bit operation preserves upper bits
; Register naming conventions ; 64-bit: RAX, RBX, RCX, RDX, RSI, RDI, RBP, RSP, R8-R15 ; 32-bit: EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP, R8D-R15D ; 16-bit: AX, BX, CX, DX, SI, DI, BP, SP, R8W-R15W ; 8-bit: AL, BL, CL, DL, SIL, DIL, BPL, SPL, R8B-R15B
```asm
; 64-bit memory addressing
mov rax, [rbx] ; 64-bit memory load
mov [rcx+rdx*8], rax ; 64-bit store with scaling
lea rsi, [rdi+r8*4+100] ; Load effective address calculation
; RIP-relative addressing (64-bit mode only)
mov rax, [rip+variable] ; PC-relative data access
call [rip+function_ptr] ; PC-relative function call
```La convención de nomenclatura de registros sigue un patrón sistemático que mantiene la compatibilidad con código de 32 bits mientras proporciona una identificación clara de los tamaños de operación. Una característica arquitectónica importante es que las operaciones de 32 bits en registros de 64 bits borran automáticamente los 32 bits superiores, proporcionando una semántica limpia para operaciones de tamaño mixto y eliminando posibles vulnerabilidades de seguridad de contenidos de registro no inicializados.
```asm
; REX prefix examples (shown conceptually)
mov rax, rbx ; REX.W + MOV (64-bit operation)
mov r8, r9 ; REX.W + REX.R + REX.B + MOV (extended registers)
mov eax, r8d ; REX.B + MOV (32-bit with extended register)
; Instruction encoding considerations
add rax, 1 ; Can use shorter encoding than immediate
add rax, 128 ; Requires longer immediate encoding
add rax, r8 ; Uses REX prefix for extended register
```x86-64 introduce el prefijo REX que permite el acceso a registros extendidos y tamaños de operandos de 64 bits mientras mantiene la compatibilidad con la codificación de instrucciones existente. El prefijo REX aparece antes del código de operación de la instrucción y contiene campos que especifican el modo de operación de 64 bits, acceso a registros extendidos y capacidades de direccionamiento adicionales. Comprender el uso del prefijo REX es crucial para programadores de ensamblador que trabajan con el conjunto de registros extendido y operaciones de 64 bits.
```asm
; 64-bit specific instructions
movsxd rax, eax ; Sign-extend 32-bit to 64-bit
cdqe ; Convert doubleword to quadword (RAX)
cqo ; Convert quadword to octword (RDX:RAX)
; Enhanced immediate support
mov rax, 0FFFFFFFFFFFFFFFFh ; 64-bit immediate (limited cases)
mov r8, 7FFFFFFFh ; 32-bit immediate sign-extended
; Improved string operations
movsq ; Move quadword string
stosq ; Store quadword string
scasq ; Scan quadword string
```El prefijo REX permite varias capacidades importantes, incluyendo acceso a registros R8-R15, especificación de tamaño de operandos de 64 bits y modos de direccionamiento extendidos. El prefijo es generado automáticamente por ensambladores cuando es necesario, pero comprender su función ayuda a optimizar la selección de instrucciones y comprender las implicaciones de tamaño de código.
```asm
; System V ABI parameter passing
; Integer/pointer parameters: RDI, RSI, RDX, RCX, R8, R9
; Floating-point parameters: XMM0-XMM7
; Return values: RAX (integer), XMM0 (floating-point)
function_call_example:
; Prepare parameters
mov rdi, param1 ; First parameter
mov rsi, param2 ; Second parameter
mov rdx, param3 ; Third parameter
mov rcx, param4 ; Fourth parameter
mov r8, param5 ; Fifth parameter
mov r9, param6 ; Sixth parameter
; Additional parameters go on stack
call target_function
; Return value in RAX
; Function prologue/epilogue
target_function:
push rbp ; Save frame pointer
mov rbp, rsp ; Establish frame pointer
sub rsp, 32 ; Allocate local storage (16-byte aligned)
; Function body
mov rax, rdi ; Access first parameter
add rax, rsi ; Add second parameter
; Function epilogue
mov rsp, rbp ; Restore stack pointer
pop rbp ; Restore frame pointer
ret ; Return to caller
```La ABI System V requiere un alineamiento de pila de 16 bytes en los límites de llamadas de función, asegurando un rendimiento óptimo para operaciones SIMD y manteniendo la compatibilidad con código generado por compiladores. La ABI también define registros guardados por el llamado (RBX, RBP, R12-R15) que deben preservarse entre llamadas de función, y registros guardados por el llamador que pueden ser modificados por funciones llamadas.
```asm
; Microsoft x64 ABI parameter passing
; Integer/pointer parameters: RCX, RDX, R8, R9
; Floating-point parameters: XMM0-XMM3
; Return values: RAX (integer), XMM0 (floating-point)
windows_function_call:
; Prepare parameters
mov rcx, param1 ; First parameter
mov rdx, param2 ; Second parameter
mov r8, param3 ; Third parameter
mov r9, param4 ; Fourth parameter
; Additional parameters go on stack
sub rsp, 32 ; Allocate shadow space
call target_function
add rsp, 32 ; Clean up shadow space
; Return value in RAX
; Windows function structure
windows_function:
; Shadow space automatically allocated by caller
mov [rsp+8], rcx ; Can spill parameters to shadow space
mov [rsp+16], rdx
mov [rsp+24], r8
mov [rsp+32], r9
; Function body
mov rax, rcx ; Access first parameter
add rax, rdx ; Add second parameter
ret ; Return to caller
```La convención de llamadas de Microsoft x64 requiere la asignación de espacio de sombra para los primeros cuatro parámetros, incluso cuando se pasan en registros. Este espacio de sombra proporciona almacenamiento para parámetros de registro si la función llamada necesita descargarlos a memoria, simplificando la implementación de funciones y la depuración.
```asm
; Page table manipulation (system-level programming)
mov cr3, rax ; Load page directory base
mov rax, cr3 ; Read current page directory
; TLB management
invlpg [memory_address] ; Invalidate specific page in TLB
mov rax, cr4 ; Read control register 4
or rax, 80h ; Set PGE bit (Page Global Enable)
mov cr4, rax ; Enable global pages
; Memory type and caching control
mov rcx, 277h ; IA32_PAT MSR
rdmsr ; Read Page Attribute Table
; Modify EAX/EDX for memory type configuration
wrmsr ; Write modified PAT
```Comprender la gestión de memoria virtual es crucial para programación a nivel de sistema, controladores de dispositivos y aplicaciones que requieren control preciso del comportamiento de memoria. La unidad de gestión de memoria de x86-64 proporciona características para protección de memoria, control de caché y optimización de rendimiento que pueden impactar significativamente el comportamiento de la aplicación.
```asm
; Large page allocation (conceptual - typically done through OS APIs)
; 2MB page allocation
mov rax, 200000h ; 2MB page size
mov rbx, page_address ; Must be 2MB aligned
; Huge page allocation
mov rax, 40000000h ; 1GB page size
mov rbx, huge_page_addr ; Must be 1GB aligned
; Page size detection
cpuid ; Check processor capabilities
test edx, 8 ; Test PSE bit (Page Size Extension)
jnz large_pages_supported
```El uso de páginas grandes requiere una consideración cuidadosa de la alineación de memoria, estrategias de asignación y soporte del sistema operativo. Las aplicaciones que pueden usar efectivamente páginas grandes a menudo ven mejoras de rendimiento significativas en cargas de trabajo intensivas en memoria.
```asm
; SSE operations (128-bit vectors)
movaps xmm0, [source] ; Load 4 packed single-precision floats
addps xmm0, xmm1 ; Add 4 floats in parallel
movaps [dest], xmm0 ; Store result
; AVX operations (256-bit vectors)
vmovaps ymm0, [source] ; Load 8 packed single-precision floats
vaddps ymm0, ymm0, ymm1 ; Add 8 floats in parallel
vmovaps [dest], ymm0 ; Store result
; Integer SIMD operations
movdqa xmm0, [int_array] ; Load 4 packed 32-bit integers
paddd xmm0, xmm1 ; Add 4 integers in parallel
movdqa [result], xmm0 ; Store result
```La programación SIMD requiere comprensión de los requisitos de alineación de datos, selección de instrucciones y estrategias de vectorización. El uso efectivo de instrucciones SIMD puede proporcionar mejoras de rendimiento de 4x, 8x o incluso 16x para algoritmos adecuados.
```asm
; AVX-512 operations (512-bit vectors)
vmovaps zmm0, [source] ; Load 16 packed single-precision floats
vaddps zmm0, zmm0, zmm1 ; Add 16 floats in parallel
vmovaps [dest], zmm0 ; Store result
; Masked operations
kmovw k1, eax ; Load mask register
vaddps zmm0\\\\{k1\\\\}, zmm1, zmm2 ; Conditional addition based on mask
; Gather operations
vgatherdps zmm0\\\\{k1\\\\}, [rsi+zmm1*4] ; Gather floats using index vector
```La programación de AVX-512 requiere una atención cuidadosa al soporte del procesador, consideraciones térmicas y efectos de escalado de frecuencia que pueden impactar el rendimiento general del sistema.
```asm
; Control register access
mov rax, cr0 ; Read control register 0
or rax, 1 ; Set PE bit (Protection Enable)
mov cr0, rax ; Enable protected mode
mov rax, cr4 ; Read control register 4
or rax, 200h ; Set OSFXSR bit (OS FXSAVE/FXRSTOR support)
mov cr4, rax ; Enable SSE support
; Model-specific register access
mov rcx, 1Bh ; IA32_APIC_BASE MSR
rdmsr ; Read MSR (result in EDX:EAX)
or eax, 800h ; Set APIC Global Enable
wrmsr ; Write MSR
```La programación de sistema requiere comprender los niveles de privilegio, mecanismos de protección de memoria e interfaces de hardware que forman la base de la funcionalidad del sistema operativo.
```asm
; Control Flow Integrity (Intel CET)
endbr64 ; End branch instruction (indirect branch target)
wrss rax, [rbx] ; Write to shadow stack
rdsspq rax ; Read shadow stack pointer
; Memory Protection Keys (Intel MPK)
mov eax, 0 ; Protection key 0
mov ecx, 0 ; Access rights
wrpkru ; Write protection key rights
; Pointer Authentication (future/ARM-inspired)
; Conceptual - not yet in x86-64
; pacia rax, rbx ; Sign pointer in RAX with key in RBX
; autia rax, rbx ; Authenticate pointer
```La utilización de características de seguridad requiere coordinación entre capacidades de hardware, soporte del sistema operativo y diseño de aplicaciones para proporcionar una protección efectiva contra técnicas de ataque modernas.
```asm
; Optimized instruction selection
lea rax, [rbx+rcx] ; Faster than mov+add for address calculation
shl rax, 3 ; Faster than imul rax, 8 for power-of-2 multiply
test rax, rax ; Faster than cmp rax, 0 for zero test
; Loop optimization
align 16 ; Align loop entry point
loop_start:
; Unroll loop body for better throughput
mov rax, [rsi] ; Load first element
add rax, [rsi+8] ; Add second element
mov [rdi], rax ; Store result
mov rax, [rsi+16] ; Load third element
add rax, [rsi+24] ; Add fourth element
mov [rdi+8], rax ; Store result
add rsi, 32 ; Advance source pointer
add rdi, 16 ; Advance destination pointer
sub rcx, 4 ; Decrement counter by 4
jnz loop_start ; Continue if not zero
```El desenrollamiento de bucles, reordenamiento de instrucciones y asignación cuidadosa de registros pueden mejorar significativamente el rendimiento para secciones de código computacionalmente intensivas.
```asm
; Cache-friendly memory access
; Sequential access pattern (cache-friendly)
mov rsi, array_start
mov rcx, element_count
sequential_loop:
mov rax, [rsi] ; Load element
; Process element
add rsi, 8 ; Move to next element
dec rcx
jnz sequential_loop
; Prefetch instructions for cache optimization
prefetcht0 [rsi+64] ; Prefetch to L1 cache
prefetcht1 [rsi+128] ; Prefetch to L2 cache
prefetcht2 [rsi+256] ; Prefetch to L3 cache
prefetchnta [rsi+512] ; Prefetch non-temporal (bypass cache)
```La utilización efectiva de caché requiere comprender los tamaños de línea de caché, estrategias de prefetch y patrones de acceso a memoria que minimicen los fallos de caché y maximicen la utilización del ancho de banda de memoria.
[The final paragraph would be translated similarly, maintaining the same structure and technical terminology.]