libasm → Making My Own ASM Library & LLDB Debugging

어셈블리어란?

int a;
int b;
int c;
a = 1;
b = 2;
c = a + b;

c7 45 fc 00 00 00 00
c7 45 f8 01 00 00 00
c7 45 f4 02 00 00 00
8b 45 f8
03 45 f4
89 45 f0

mov    DWORD PTR [rbp-0x4],0x0 ; 스택에 4바이트 길이의 0을 저장 (위에서 'c' 변수)
mov    DWORD PTR [rbp-0x8],0x1 ; 스택에 4바이트 길이의 1을 저장 (위에서 'a' 변수)
mov    DWORD PTR [rbp-0xc],0x2 ; 스택에 4바이트 길이의 2을 저장 (위에서 'b' 변수)
mov    eax,DWORD PTR [rbp-0x8] ; eax 라는 cpu 레지스터에 a 변수를 꺼내옴
add    eax,DWORD PTR [rbp-0xc] ; eax 라는 cpu 레지스터에 b 변수를 더함
mov    DWORD PTR [rbp-0x4],eax ; c 변수에 eax 레지스터 저장

C나 자바 등을 놔두고 복잡하고 어려운 어셈블리어를 사용하는 이유는?

C언어로 컴파일 한 실행파일의 어셈블리어 보기

# 컴파일 (실행파일 자체가 기계어임)
$> gcc main.c
# 기계어를 어셈블리어로 보기 (리눅스)
$> objdump -d -M intel ./a.out
# 기계어를 어셈블리어로 보기 (맥os)
$> objdump -d --x86-asm-syntax=intel a.out

어셈블리어 아주 기초 문법

어셈블리어 기본 문법

opcode                    ; 인자 없이 명령만 실행
opcode operand1           ; 인자를 하나만 받음
opcode operand1 operand2  ; 인자를 두개 받음

opcode (명령어)

operand (인자)

예제

syscall       ; 시스템 콜 호출
cmp [addr], 0 ; addr이 가리키는 메모리 값과 0을 비교
mov a, b      ; b 레지스터의 값을 a로 이동 (복사)
add a, b      ; a 레지스터에 b 값을 더함

• 메모리 값

• 상수

• 레지스터

libasm

요구사항

• asm 파일 및 Makefile을 이용하여 libasm.a (정적 라이브러리) 를 만들 수 있어야 함.

• asm 파일의 확장자는 .s임.

• 어셈블리어의 컴파일러는 nasm을 사용해야 한다.

• Intel 문법을 사용해야 함.

• 64비트 양식으로 작성해야 하며 "calling convention"을 숙지

• Makefile을 작성해야 하며 가지고 있어야 하는 명령어는 기존과 동일, 보너스도 마찬가지

• 프로젝트에 대한 테스트 프로그램(코드)는 선택사항으로 제출하며 이를 이용해 defense 하면 편함. 테스트 프로그램에서는 궂이 코딩룰을 지킬필요 없음 (근데 테스트를 위한 main 함수는 함께 제출하라고 함. 뭐지?)

• 인라인 ASM을 작성하면 안됨

• syscalls 도중에 에러가 발생하는지 반드시 체크해야 하며 필요시 에러 관리

• errno 변수를 적절하게 관리 (이를 위해 extern ___error 호출 허용)

구현해야 하는 함수

• ft_strlen (man 3 strlen)

• ft_strcpy (man 3 strcpy)

• ft_strcmp (man 3 strcmp)

• ft_write (man 2 write)

• ft_read (man 2 read)

• ft_strdup(man 3 strdup, malloc을 call할 수 있습니다.)

요구사항 분석하며 과제 진행하기

nasm 사용해보기

; ----------------------------------------------------------------------------------------
; Writes "Hello, World" to the console using only system calls. Runs on 64-bit macOS only.
; To assemble and run:
;
;     nasm -fmacho64 hello.asm && ld hello.o && ./a.out
; ----------------------------------------------------------------------------------------

          global    start

          section   .text
start:    mov       rax, 0x02000004         ; system call for write
          mov       rdi, 1                  ; file handle 1 is stdout
          mov       rsi, message            ; address of string to output
          mov       rdx, 13                 ; number of bytes
          syscall                           ; invoke operating system to do the write
          mov       rax, 0x02000001         ; system call for exit
          xor       rdi, rdi                ; exit code 0
          syscall                           ; invoke operating system to exit

          section   .data
message:  db        "Hello, World", 10      ; note the newline at the end

$> nasm -fmacho64 hello.s && ld -macosx_version_min 10.7.0 hello.o && ./a.out

objdump -d --x86-asm-syntax=intel hello.o

hello.o:  file format Mach-O 64-bit x86-64


Disassembly of section __TEXT,__text:

0000000000000000 start:
       0: b8 04 00 00 02                 mov  eax, 33554436
       5: bf 01 00 00 00                 mov  edi, 1
       a: 48 be 00 00 00 00 00 00 00 00  movabs  rsi, 0
      14: ba 0d 00 00 00                 mov  edx, 13
      19: 0f 05                          syscall
      1b: b8 01 00 00 02                 mov  eax, 33554433
      20: 48 31 ff                       xor  rdi, rdi
      23: 0f 05                          syscall

nasm에서 사용하는 어셈블리어 기본 문법

• .data

• .bss

• .text

.data

.bss

.text

주석

명령어 한줄한줄

[label]   mnemonic   [operands]   [;comment]

메모리

예제

MOV BYTE [메모리주소], 데이터 ; 메모리 주소가 가리키는 곳에 데이터 삽입
MOV QWORD [메모리주소], 데이터 ; 메모리 주소가 가리키는 곳에 8바이트 데이터 삽입

레지스터

범용 레지스터 (Intel 64bit CPU 기준)

• 데이터 레지스터 (밑 4가지 레지스터가 대표적이다.)
• Accumulator (누산기, 산술 연산에 사용)
• Base (주소 지정에 사용)
• Count (반복문 카운트)
• Data (Data I/O)

• 64비트 CPU에서는 64비트 길이를 가지며 32비트 CPU에서는 32비트 길이를 가진다.

• 레지스터의 명칭을 바꾸어 다른 길이로 접근이 가능하다.
• Accumulator, Base, Count, Data 각각 앞 알파벳을 따서 A, B, C, D로 구분하는 것을 기본으로 앞뒤에 접두사를 붙여 길이를 구분한다.
• R@X - E@X - @X - @H - @L (@ = A, B, C, D) [64비트] - [32비트] - [16비트] - [16비트의 왼쪽 8비트] - [8비트]
• 예를 들어 64비트의 누산기 레지스터는 RAX이며 16비트 카운트 레지스터는 CX이다.

• 위 4가지 레지스터는 원래 본 기능이 존재하지만 다른 용도로도 많이 사용한다. (예를 들면 시스템 콜)

• 포인터 레지스터
• 메모리의 주소를 가리킨다.
• IP (Instruction Pointer, 명령어 포인터) : 다음에 실행될 명령어가 들어있는 메모리 주소를 가리킨다.
• SP (Stack Pointer) : 프로그램이 사용하는 스택 메모리의 주소를 가리킨다.
• BP (Base Pointer) : 스택의 특정 기준점을 의미함.
• 64비트에서 각 포인터는 RIP, RSP, RBP이다.
• 보통 서브 루틴의 지역 변수는 스택에 저장되기 때문에 C에서 지역변수를 선언하면 해당 변수는 스택에 쌓이게 된다.

• 인덱스 레지스터
• 보통 메모리에 일렬로 저장된 데이터에 접근 시 사용함.
• SI (Source Index)
• DI (Dest. Index)

제어 레지스터

• 플래그 형태로 사용하며 산술연산을 할 때에나 인터럽트 사용 여부 등을 정할 수 있다.

• 산술 연산을 할 때 오버플로우가 발생하거나 연산 결과가 짝수이거나 등을 플래그로 확인할 수 있다.

세그먼트 레지스터

• 프로그램에서 메모리의 어떤 부분이 사용되는지 명시한다. 예를 들면 코드 영역 / 데이터 영역 / 스택 영역이 메모리에서 구분되는데 이런 구분을 하기 위해서 사용한다.

Syscall

• System Call = syscall

• 운영 체제(커널)가 기본적으로 제공하는 서비스가 있음. (화면에 글자 출력하는것부터 파일 열고 닫기, 통신 등등)

• 예를 들어 printf나 write 함수를 사용해서 쉘에 글자를 출력하는 것은 printf나 write 라는 표준 함수를 이용해서 화면에 출력하는 것이지 사용자가 직접 화면에 픽셀을 바꿔서 글자를 출력하는 것이 아님.

• 왜냐 하면 그런 일들은 운영체제(커널)가 할 수 있는 일임. system call은 커널에 그런 것을 하도록 요청하는 것임.

• 어셈블리어로 코딩을 할 때에 화면 입출력, 파일조작 등 시스템 기능에 접근해야 할 일이 있을 때 Syscall을 이용한다.

NASM에서 시스템콜 사용하기

1. 누산기 레지스터 (RAX)에 시스템 콜 넘버를 집어넣는다.

2. 시스템 콜 매개변수를 Base, Count, Data 등 CPU 레지스터에 집어넣는다.

3. System Call 명령을 실행한다. (참고로 32비트 환경에서는 int 0x80 명령어로 시스템 콜을 호출한다.)

4. System Call 명령이 실행되고 반환된 결과는 보통 누산기 레지스터에 저장된다.

서브루틴 (함수) 호출

NASM에서 변수 선언

message:  db        "Hello, World", 10

예제 프로그램 뜯어보기

          global    start

          section   .text
start:    mov       rax, 0x02000004     ; write() 기능을 하는 시스템 콜을 사용하기 위해
                                        ; 누산기 레지스터에 sys/syscall.h에 명시되어 있는
                                        ; (SYS_write) 값을 집어넣음
                                        ; write(int fildes, const void *buf, size_t nbyte);
          mov       rdi, 1              ; fildes에 정수 1 대입
          mov       rsi, message        ; *buf에 출력할 메모리 주소 대입
          mov       rdx, 13             ; nbyte에 출력할 바이트 길이 대입
          syscall                       ; 시스템 함수 콜
          mov       rax, 0x02000001     ; exit(int status);
          xor       rdi, rdi            ; status에 0 대입 (mov rdi, 0 과 동일함.)
          syscall                       ; 시스템 콜

          section   .data
message:  db        "Hello, World", 10  ; "Hello, World\n"

동일한 기능을 C언어로 표현

#include <unistd.h>
#include <stdlib.h>
int main(void)
{
  char  message[13] = "Hello, World\n";
  write(1, message, 13);
  exit(0);
  return (0);
}

라벨

시스템 콜과 표준 함수와의 관계

$> gcc -o test main1.c
$> ./test
Hello, World
$> objdump -d --x86-asm-syntax=intel test

0000000100003f20 _main:
100003f20: 55                                    push  rbp ; 함수 프롤로그
100003f21: 48 89 e5                              mov  rbp, rsp ; 함수 프롤로그
100003f24: 48 83 ec 20                           sub  rsp, 32 ; 32바이트의 스택을 해당루틴에서 사용
100003f28: c7 45 fc 00 00 00 00                  mov  dword ptr [rbp - 4], 0 ; 4바이트의 지역변수에 0 저장
100003f2f: 48 b8 2c 20 57 6f 72 6c 64 0a         movabs  rax, 748842676800397356 ; 특정 상수를 누산기에 저장
100003f39: 48 89 45 ed                           mov  qword ptr [rbp - 19], rax ; 8바이트의 지역변수에 누산기 값 저장
100003f3d: 48 b8 48 65 6c 6c 6f 2c 20 57         movabs  rax, 6278066737626506568 ; 특정 상수 2를 누산기에 저장
100003f47: 48 89 45 e8                           mov  qword ptr [rbp - 24], rax ; 8바이트의 다른 지역변수에 누산기 값 저장
100003f4b: bf 01 00 00 00                        mov  edi, 1 ; write()의 첫번째 인수
100003f50: 48 8d 75 e8                           lea  rsi, [rbp - 24] ; write()의 두번쨰 인수 (위 특정 상수가 문자열 메모리 위치인듯)
100003f54: ba 0d 00 00 00                        mov  edx, 13 ; write()의 세번째 인수
100003f59: e8 12 00 00 00                        call  18 <dyld_stub_binder+0x100003f70> ; 동적 라이브러리에서 함수 호출
100003f5e: 31 ff                                 xor  edi, edi ; exit()의 첫번째 인수 (레지스터에 0 대입할때는 mov보다 xor을 주로씀)
100003f60: 48 89 45 e0                           mov  qword ptr [rbp - 32], rax ; write()의 리턴값을 8바이트의 지역변수에 저장
100003f64: e8 01 00 00 00                        call  1 <dyld_stub_binder+0x100003f6a> ; 동적 라이브러리에서 함수 호출

시스템 콜 레퍼런스

시스템 콜 (운영체제)

*nix, 어셈블리어 환경에서 시스템 콜 호출

어셈블리 명령어

산술연산

• a에 1을 더함 : inc a

• a에 1을 뺌 : dec a

• a에 b를 더함 : add a, b

• a에 b를 뺌 : sub a, b

• a에 b를 곱함 : mul a, b (mul 외에 여러 변형이 있을 수 있음)

• a에 b를 나눔 : div a, b (div 외에 여러 변형이 있을 수 있음)

• a에 b를 나는 나머지 : 별도 명령어가 없고 나누면 나머지 값이 별도 레지스터에 저장됨

스택 연산

• 스택에 값 a 넣기 : push a

• 스택에서 값 a 빼기 : pop a

값 대입

• a에 b값 넣기 : mov a, b

값 비교 후 분기

• cmp 명령어로 비교함 : cmp a, b

• 비교한 결과는 플래그 레지스터에 저장됨

• jXX 명령어로 원하는 부분으로 분기함

서브루틴 호출 및 복귀

• 일반 서브루틴 호출 : call [서브루틴]

• 시스템 콜 호출 : syscall (단 시스템 콜을 사용하기 전에 특정 레지스터에 시스템 콜 번호를 넣어야 함)

• 종료 후 이전 루틴으로 복귀 : ret

• 보통 서브루틴의 리턴값은 누산기 레지스터에 저장한다.

어셈블리어로 모듈 만들어보기

모듈 예제

;func.s / char  genascii(void);
global    _genascii

section    .text
_genascii:      MOV    AL, 119      ; 누산기 레지스터에 리턴할 값을 집어넣음. (119 -> ascii 'w')
                RET                ; return

// main.c
#include <stdio.h>char  genascii(void);
int main(void)
{
  char c;
  c = genascii();
  printf("%c\n", c);
}

$> nasm -fmacho64 func.s
$> gcc main.c func.o
$> ./a.out
w

모듈 예제 2

;addascii.s / char  addascii(char);
global    _addascii

section    .text
_addascii:      MOV    AL, DIL    ; 입력 인수를 누산기 레지에 더함
                CMP    AL, 'a'    ; 누산기에 저장된 입력 인수와 ascii 'a'와 비교
                JL    rtn        ; 저 아스키 코드보다 작으면 종료 루틴으로 건너뜀
                CMP    AL, 'z'    ; 누산기에 저장된 입력 인수와 ascii 'z'와 비교
                JG    rtn        ; 저 아스키 코드보다 크면 종료 루틴으로 건너뜀
                INC    AL        ; 아스키 코드 1 증가
                JMP    rtn        ; 리턴 루틴으로 건너뜀

rtn:            RET              ; 종료

// main.c
#include <stdio.h>
char    addascii(char c);
int      main(void)
{
  char  ct;
  for (char c = 'a'; c < 'z'; c++)
  {
    ct = addascii(c);
    printf("%c -> %c\n", c, ct);
  }
  for (char c = 'A'; c < 'Z'; c++)
  {
    ct = addascii(c);
    printf("%c -> %c\n", c, ct);
  }
}

$> nasm -fmacho64 addascii.s
$> gcc main.c addascii.o
$> ./a.out
[소문자 알파벳은 다음 문자가 더해지고 대문자 알파벳은 그대로 출력됨]

errno와 errno.h

___error ?

#define errno (*__error())

strlen 구현

필요 파일

%.o: %.s
  $(ASMCOMPILER) $(ASMFLAGS) $<

$(NAME): $(OBJS)
  ar rc $(NAME) $(OBJS)
  ranlib $(NAME)

man 3 strlen

size_t strlen(const char *s);

주의해야 할 점

• 입력 인수는 포인터다. 포인터의 길이는 64비트다. (현재 개발환경이 cpu가 64비트임. 그러면 메모리 주소의 길이도 64비트이다. 따라서 입력 인수를 받을 때 64비트-8바이트 QWORD 길이로 받아야 한다.)

• 카운트 변수 + 입력 인수로 메모리에 접근할 때 카운트 변수도 8바이트로 접근해야 한다. 하지만 리턴값은 4바이트(int)이다. 크게 문제가 되진 않는 것 같지만 추후에 다른 문제가 발생할 여지 정도는 있는것 같다.

• 카운트 할 레지스터를 XOR 연산을 이용해서 0으로 초기화 하자.

핵심 코드

CMP    BYTE [RDI + RAX], 0    ; 1바이트 크기의 인수로 받은 포인터 위치 값과 0(char null) 비교
JE    rtn                    ; JE (Jump Equal) - 같으면 종료
INC    RAX                    ; 같지 않으면 누산기 레지 1 증가

strcpy 구현

man strcpy

MOV    BYTE [RAX], BYTE [RSI]

MOV    RDX, BYTE [RAX]
MOV    BYTE [RSI], RDX

strcmp 구현

int      ft_strcmp(char *s1, char *s2)
{
  while (!(*s1 == '\0' && *s2 == '\0'))
  {
    if (*s1 != *s2)
      return ((int)(*s1 - *s2));
    s1++;
    s2++;
  }
  return (0);
}

int      ft_strcmp(char *s1, char *s2)
{
  while (*s1 == *s2)
  {
    if (*s1 == '\0')
      break ;
    s1++;
    s2++;
  }
  return ((int)(*s1 - *s2));
}

write 구현

ssize_t    write(int fildes, const void *buf, size_t nbyte);

_ft_write:      MOV    RAX, 0x02000004  ; 시스템 콜을 사용하기 위해 누산기 레지스터에 콜 고유번호 삽입
                SYSCALL                ; 세개의 변수는 그대로 write 시스템콜에 들어가므로 별도로 삽입하지 않음.
                RET                    ; 종료

extren 키워드

C에서 errno 동작 확인

#include <stdio.h>
#include <sys/errno.h>int main(void)
{
  long rtn;
  printf("errno : %d\n", errno);
  rtn = write(-1, "hi", 2);
  printf("errno : %d\n", errno);
  printf("rtn : %ld\n", rtn);
  return (0);
}

errno : 0
errno : 9
rtn : -1

시스템 콜에서 에러 발생 시 확인하는 법

__error()과 errno

read()

strdup()

이상한 점

global    _ft_strdup
extern    _malloc

section    .text
_ft_strdup:     MOV    RDI, 10         ; malloc 입력인수 (10)
                CALL  _malloc          ; malloc 호출
                RET                    ; 종료

-fsanitize=address -g

AddressSanitizer:DEADLYSIGNAL
=================================================================
==34860==ERROR: AddressSanitizer: SEGV on unknown address (pc 0x7fff2034a3ee bp 0x7ffeeba748d0 sp 0x7ffeeba74888 T0)
==34860==The signal is caused by a READ memory access.
==34860==Hint: this fault was caused by a dereference of a high value address (see register values below).  Dissassemble the provided pc to learn which register was used.
    #0 0x7fff2034a3ee in stack_not_16_byte_aligned_error+0x0 (libdyld.dylib:x86_64+0x143ee)
    #1 0x10418c85c in main test.c:32
    #2 0x7fff2034b620 in start+0x0 (libdyld.dylib:x86_64+0x15620)

==34860==Register values:
rax = 0x00006020000000d0  rbx = 0x0000000000000000  rcx = 0x7365742079706f63  rdx = 0x0000000000000005
rdi = 0x000000000000007b  rsi = 0x000000010418ed80  rbp = 0x00007ffeeba748d0  rsp = 0x00007ffeeba74888
 r8 = 0x0031232074736574   r9 = 0x0000000000000000  r10 = 0xffffffffffffffff  r11 = 0x0000000104193d20
r12 = 0x0000000000000000  r13 = 0x0000000000000000  r14 = 0x0000000000000000  r15 = 0x0000000000000000
AddressSanitizer can not provide additional info.
SUMMARY: AddressSanitizer: SEGV (libdyld.dylib:x86_64+0x143ee) in stack_not_16_byte_aligned_error+0x0
==34860==ABORTING

• r (프로그램 실행)

• b [브레이크 걸 심볼] (브레이크포인트를 걸 위치 (함수명 등))

• n [한 라인씩 실행]

• q (종료)

• register read (현재 레지스터 보기)

1. lldb [프로그램]

2. [(lldb) settings set target.x86-disassembly-flavor intel] // 출력되는 어셈 문법을 인텔 형식으로 출력

3. [(lldb) b [브레이크포인트 심볼]

4. [(lldb) r

5. (lldb) n

$> lldb test
(lldb) target create "test"
Current executable set to '/Users/joohongpark/Documents/code/42/42cursus/libasm/test' (x86_64).
(lldb) b ft_strdup
Breakpoint 1: where = test`ft_strdup, address = 0x0000000100002ab7
(lldb) r
Process 35058 launched: '/Users/joohongpark/Documents/code/42/42cursus/libasm/test' (x86_64)
strdup test
Process 35058 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
    frame #0: 0x0000000100002ab7 test`ft_strdup
test`ft_strdup:
->  0x100002ab7 <+0>:  movl   $0x7b, %edi
    0x100002abc <+5>:  callq  0x1000030f8               ; symbol stub for: malloc
    0x100002ac1 <+10>: retq
    0x100002ac2 <+11>: movq   %rax, %rdi
Target 0: (test) stopped.
(lldb) n
Process 35058 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = instruction step over
    frame #0: 0x0000000100002abc test`ft_strdup + 5
test`ft_strdup:
->  0x100002abc <+5>:  callq  0x1000030f8               ; symbol stub for: malloc
    0x100002ac1 <+10>: retq
    0x100002ac2 <+11>: movq   %rax, %rdi
    0x100002ac5 <+14>: subq   $0x8, %rsp
Target 0: (test) stopped.
(lldb) n
Process 35058 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = EXC_BAD_ACCESS (code=EXC_I386_GPFLT)
    frame #0: 0x00007fff2034a3ee libdyld.dylib`stack_not_16_byte_aligned_error
libdyld.dylib`stack_not_16_byte_aligned_error:
->  0x7fff2034a3ee <+0>: movdqa %xmm0, (%rsp)
    0x7fff2034a3f3 <+5>: int3

libdyld.dylib`_dyld_fast_stub_entry:
    0x7fff2034a3f4 <+0>: pushq  %rbp
    0x7fff2034a3f5 <+1>: movq   %rsp, %rbp
Target 0: (test) stopped.
(lldb) exit
Quitting LLDB will kill one or more processes. Do you really want to proceed: [Y/n] Y

함수의 프롤로그와 에필로그와 위 오류 수정

0000000100003e70 _strcmp:
100003e70: 55                            push  rbp
100003e71: 48 89 e5                      mov  rbp, rsp
100003e74: 48 89 7d f8                   mov  qword ptr [rbp - 8], rdi
100003e78: 48 89 75 f0                   mov  qword ptr [rbp - 16], rsi
100003e7c: 48 8b 45 f8                   mov  rax, qword ptr [rbp - 8]
100003e80: 0f be 08                      movsx  ecx, byte ptr [rax]
100003e83: 48 8b 45 f0                   mov  rax, qword ptr [rbp - 16]
100003e87: 0f be 10                      movsx  edx, byte ptr [rax]
100003e8a: 39 d1                         cmp  ecx, edx
100003e8c: 0f 85 36 00 00 00             jne  54 <_strcmp+0x58>
100003e92: 48 8b 45 f8                   mov  rax, qword ptr [rbp - 8]
100003e96: 0f be 08                      movsx  ecx, byte ptr [rax]
100003e99: 83 f9 00                      cmp  ecx, 0
100003e9c: 0f 85 05 00 00 00             jne  5 <_strcmp+0x37>
100003ea2: e9 21 00 00 00                jmp  33 <_strcmp+0x58>
100003ea7: 48 8b 45 f8                   mov  rax, qword ptr [rbp - 8]
100003eab: 48 05 01 00 00 00             add  rax, 1
100003eb1: 48 89 45 f8                   mov  qword ptr [rbp - 8], rax
100003eb5: 48 8b 45 f0                   mov  rax, qword ptr [rbp - 16]
100003eb9: 48 05 01 00 00 00             add  rax, 1
100003ebf: 48 89 45 f0                   mov  qword ptr [rbp - 16], rax
100003ec3: e9 b4 ff ff ff                jmp  -76 <_strcmp+0xc>
100003ec8: 48 8b 45 f8                   mov  rax, qword ptr [rbp - 8]
100003ecc: 0f be 08                      movsx  ecx, byte ptr [rax]
100003ecf: 48 8b 45 f0                   mov  rax, qword ptr [rbp - 16]
100003ed3: 0f be 10                      movsx  edx, byte ptr [rax]
100003ed6: 29 d1                         sub  ecx, edx
100003ed8: 89 c8                         mov  eax, ecx
100003eda: 5d                            pop  rbp
100003edb: c3                            ret

100003e70: 55                            push  rbp
100003e71: 48 89 e5                      mov  rbp, rsp
; 코드 내용
100003eda: 5d                            pop  rbp
100003edb: c3                            ret

global    _ft_strdup
extern    _malloc

section    .text
_ft_strdup:      PUSH  RBP              ; 프롤로그
                MOV    RBP, RSP        ; 프롤로그
                MOV    RDI, 10          ; malloc 입력인수 (10)
                CALL  _malloc          ; malloc 호출
                POP    RBP              ; 에필로그
                RET                    ; 종료