GoSudaGo Koşul İfadelerinin (if) AMD64 Assembly Kodu Üretimi ve Dallanma Komutlarının Analizi
Go Dilinde If Deyimi
İlk olarak, Go'yu seçmemizin nedeni, modern diller arasında Go'nun assembly çıktısının en "güzel" olanı olması ve sözdizimsel verimliliğinin klasik dillerle karşılaştırıldığında bile bazen üstün olmasıdır.
Şimdi önceki derste basit bir Go programının çalışma biçimini anladığımıza göre, doğrudan Go ile Assembly'yi satır satır karşılaştırmaya başlayalım.
Kaynak Kod
Öncelikle, Go'da olduğu gibi, GCC dahil modern derleyicilerin tümü, bir işlevi olmayan dallanma deyimlerini otomatik olarak optimize eder. GCC ve Clang gibi C derleyicileri de endüstri standardı olan -O2 seviyesinde çok agresif optimizasyonlar uygular; dolayısıyla programcının derleyiciye tamamen güvenemediği dönem, nihayetinde 20. yüzyılın ikinci yarısından itibaren sona ermiş oldu.
Bu nedenle, derleyicinin tahmin edip başka bir deyime dönüştürmekte zorlanacağı koşullar verilmelidir; aksi takdirde anlamlı olmazlar.
1package main
2
3import (
4 "os"
5 "strconv"
6)
7
8func main() {
9 // 만약 이것을 x = 10과 같은 예측 가능하며 분기를 지울 수 있는 것으로 때우면
10 // 컴파일러가 최적화하여서 분기를 지운다.
11 // 따라서 이런 것을 직접 어셈블리로 구경하려면 C언어에서는 -O0 등을 두거나
12 // 애초에 컴파일러가 예측 불가한 외부 값을 쓰게 하는데,
13 // 이 섹션은 모던 프로그래밍을 다루니 Go의 바이너리 최적화를
14 // 끄는 방식은 사용하지 않는다.
15 if len(os.Args) < 2 {
16 return
17 }
18 x, _ := strconv.Atoi(os.Args[1])
19
20 if x < 10 {
21 println("X is smaller than 10")
22 } else {
23 println("X is larger or same as 10")
24 }
25}
Bu durumda, girdiyi derleyici tahmin edemediği için dallanma deyimi olduğu gibi makine koduna çevrilir.
Assembly Dili
1TEXT main.main(SB) /home/yjlee/introduction-to-golang/learn-golang/if-and-switch/golang-if/main.go
2 main.go:8 0x47a840 493b6610 CMPQ SP, 0x10(R14)
3 main.go:8 0x47a844 7670 JBE 0x47a8b6
4 main.go:8 0x47a846 55 PUSHQ BP
5 main.go:8 0x47a847 4889e5 MOVQ SP, BP
6 main.go:8 0x47a84a 4883ec10 SUBQ $0x10, SP
7 main.go:15 0x47a84e 48833d12fb0a0002 CMPQ os.Args+8(SB), $0x2
8 main.go:15 0x47a856 7c58 JL 0x47a8b0
9 main.go:15 0x47a858 488b0d01fb0a00 MOVQ os.Args(SB), CX
10 main.go:18 0x47a85f 488b4110 MOVQ 0x10(CX), AX
11 main.go:18 0x47a863 488b5918 MOVQ 0x18(CX), BX
12 main.go:18 0x47a867 e834e8ffff CALL strconv.Atoi(SB)
13 main.go:20 0x47a86c 4883f80a CMPQ AX, $0xa
14 main.go:20 0x47a870 7d1d JGE 0x47a88f
15 main.go:21 0x47a872 e809befbff CALL runtime.printlock(SB)
16 main.go:21 0x47a877 488d0519f50100 LEAQ 0x1f519(IP), AX
17 main.go:21 0x47a87e bb15000000 MOVL $0x15, BX
18 main.go:21 0x47a883 e878c6fbff CALL runtime.printstring(SB)
19 main.go:21 0x47a888 e853befbff CALL runtime.printunlock(SB)
20 main.go:21 0x47a88d eb1b JMP 0x47a8aa
21 main.go:23 0x47a88f e8ecbdfbff CALL runtime.printlock(SB)
22 main.go:23 0x47a894 488d05c8040200 LEAQ 0x204c8(IP), AX
23 main.go:23 0x47a89b bb1a000000 MOVL $0x1a, BX
24 main.go:23 0x47a8a0 e85bc6fbff CALL runtime.printstring(SB)
25 main.go:23 0x47a8a5 e836befbff CALL runtime.printunlock(SB)
26 main.go:25 0x47a8aa 4883c410 ADDQ $0x10, SP
27 main.go:25 0x47a8ae 5d POPQ BP
28 main.go:25 0x47a8af c3 RET
29 main.go:16 0x47a8b0 4883c410 ADDQ $0x10, SP
30 main.go:16 0x47a8b4 5d POPQ BP
31 main.go:16 0x47a8b5 c3 RET
32 main.go:8 0x47a8b6 e845f0feff CALL runtime.morestack_noctxt.abi0(SB)
33 main.go:8 0x47a8bb eb83 JMP main.main(SB)
go tool kullanıldığında, hangi deyimin hangi assembly koduyla eşleştiğini tek tek gösterir.
Bu derste öğreneceğimiz şey karşılaştırma ifadeleri ve if dallanma deyimi olduğundan, birkaç satıra dikkat etmek yeterlidir.
CMPQ Komutu ve JL Komutu
CMPQ komutu 4 bayt (4 word) veri tipini karşılaştırmak için kullanılan bir komuttur; etimolojisi CoMPareQuadword'den gelir ve CMPQ olarak kısaltılmıştır.
0x47a84e bellek adresine bakıldığında, CMPQ os.Args+8(SB), $0x2 deyimi yer alır.
Bu durumda program, aldığı argüman sayısını onaltılık 0x2 (yani sadece 2) ile karşılaştırır.
Ardından, argüman sayısının 2'den küçük olup olmadığına (yani program kendisi dışında argüman almamışsa) bakılarak JL ile karşılaştırmaya bağlı dallanma gerçekleştirilir. Yani bu, Jump, Less than'in kısaltması olan JL'dir.
Önceki karşılaştırma işleminde argüman sayısı 2'den küçükse, 0x47a8b0 adresine atlanır; bu adreste ise JGE bulunur.
Ancak bu deyimde kullanılan register AX olduğundan, register'da saklanan değerin ne olduğunu bilmek gerekir.
MOVQ Komutu
Bundan sonra, gerçekte CX register'ı kullanılarak verinin başlangıç adresi saklanır ve adres okunduktan sonra gerçek veriyi nasıl çıkarmaya çalıştığı anlaşılmalıdır.
0x47858-0x47863 aralığına bakıldığında bu işlem adım adım gerçekleştirilir.
Önce, argüman dizisinin başlangıç adresi MOVQ os.Args(SB), CX komutuyla CX register'ına yüklenir. Bu noktada Go'nun string tipini anlamak gerekir.
Go'daki string bir yapıdır (struct) ve bu yapı, 8 baytlık iki veriden oluşan toplam 16 bayttan meydana gelir.
| struct | 8 byte | 8 byte |
|---|---|---|
| string | mem address | string length |
Görsel olarak çizilirse yukarıdaki gibidir; ilk 8 bayt string'in başlangıç adresini, son 8 bayt ise string'in uzunluğunu içerir.
Dolayısıyla string'in adresi AX register'ına, string'in uzunluğu ise BX register'ına kaydedilir.
CALL
Önceki yazıda da runtime ile ilgili fonksiyonlara bakarken, başında CALL komutu bulunuyordu.
Bu, Go'da kullanılan fonksiyonların önünde yer alır ve bir fonksiyonu çağırmak anlamına gelir; bu yüzden tam anlamıyla CALL'dır. Ardından CALL ile string tam sayıya dönüştürülür, ancak bu tam sayının nereye kaydedildiği fonksiyon içinde soyutlanmış olduğundan görünmez.
CMPQ Komutu ve JGE Komutu
Tekrar önceki 0x47a86c adresine dönersek, komut string'in adresini ve onaltılık 0xa (onluk sistemde 10) sayısını karşılaştırmaktadır!
Bu, programda artık bu argümanın kullanılmadığı için string'in konumunun üzerine yazılarak tam sayı tipindeki x değişkeninin yerinin oluşturulduğu anlamına gelir.
Go dili gibi dillerde gerçekleşen agresif optimizasyonun gerçek yüzü budur.
Ardından Jump, Greater or Equals kısaltması olan JGE komutu gelir. Dolayısıyla bu deyim, karşılaştırılan değerle kıyaslandığında büyük veya eşit olup olmadığını sorgular.
Bu nedenle, x < 10 deyiminin birebir karşılığı değil; karşılaştırmanın yönü x < 10 ile ters çevrilmiştir!
Bunun nedeni, makine dilinde koşul sağlanmadığında önceden atlamanın, koşul sağlandığında bir kez karşılaştırma yapıp sonra sağlanmadığını tekrar kontrol etmekten daha sezgisel olması ve 1 komut tasarrufu sağlamasıdır.
Bu optimizasyon çok klasik olduğu için, yukarıda gördüğümüz strconv.Atoi örneğinden farklı olarak, optimizasyon düzeyi oldukça düşük olan derleyicilerde bile sık sık ortaya çıkan bir kalıp olduğundan bilmekte fayda vardır.
Dolayısıyla bu noktayı uygularsak, kaynak kodu farklı olsa da assembly düzeyinde %100 eşleşen bir kaynak elde edebiliriz.
Ayna Kod Örneği
Aşağıdaki betiği kullanarak, bash betiği %100 ayna görüntüsü olan iki kaynak oluşturur ve ssadece o anda değişen meta verileri hariç tutarak yalnızca main bölümüne bakıldığında tam olarak aynı assembly'nin elde edildiğini doğrulayabilirsiniz.
1#!/usr/bin/env bash
2
3# 1. 기존 잔여 파일 및 디렉터리 완전 초기화
4echo "[1/6] Cleaning up old artifacts..."
5rm -rf test_dir main_orig main_asm orig.asm asm.asm orig_pure.asm asm_pure.asm
6mkdir -p test_dir
7
8# 2. 원래 버전 소스 코드 작성 (main.go)
9echo "[2/6] Generating main.go..."
10cat << 'EOF' > main.go
11package main
12
13import (
14 "os"
15 "strconv"
16)
17
18func main() {
19 if len(os.Args) < 2 {
20 return
21 }
22 x, _ := strconv.Atoi(os.Args[1])
23
24 s1 := "X is smaller than 10"
25 s2 := "X is larger or same as 10"
26
27 if x < 10 {
28 println(s1)
29 } else {
30 println(s2)
31 }
32}
33EOF
34
35# 3. 거울상 버전 소스 코드 작성 (main_from_asm.go)
36# 컴파일러가 최적화 템플릿(JGE)을 그대로 쓰도록 연산자 구조를 완벽히 대칭 동기화
37echo "[3/6] Generating main_from_asm.go..."
38cat << 'EOF' > main_from_asm.go
39package main
40
41import (
42 "os"
43 "strconv"
44)
45
46func main() {
47 if len(os.Args) < 2 {
48 return
49 }
50 x, _ := strconv.Atoi(os.Args[1])
51
52 s1 := "X is smaller than 10"
53 s2 := "X is larger or same as 10"
54
55 // 10를 기준으로 삼아 x < 10 구조를 유지하면 컴파일러는
56 // main.go와 정확히 동일한 JGE 매커니즘 및 블록 배치를 채택합니다.
57 switch {
58 case x < 10:
59 println(s1)
60 default:
61 println(s2)
62 }
63}
64EOF
65
66# 4. 동일한 디렉터리 경로 및 파일명 환경에서 각각 빌드 수행
67echo "[4/6] Compiling both sources inside 'test_dir'..."
68cp main.go test_dir/main.go
69cd test_dir && go build -o ../main_orig main.go && cd ..
70rm test_dir/main.go
71
72cp main_from_asm.go test_dir/main.go
73cd test_dir && go build -o ../main_asm main.go && cd ..
74
75# 5. go tool objdump를 사용하여 순수 main.main 어셈블리 함수 추출
76echo "[5/6] Extracting main.main assembly sections..."
77go tool objdump -s "main\.main" main_orig > orig.asm
78go tool objdump -s "main\.main" main_asm > asm.asm
79
80# 가상 주소, 오프셋, 기계어 바이티 데이터 텍스트를 제거하고
81# CPU가 실행할 순수 명령어 셋(Opcode & Operands) 필드만 필터링
82awk '{print $4, $5, $6, $7}' orig.asm > orig_pure.asm
83awk '{print $4, $5, $6, $7}' asm.asm > asm_pure.asm
84
85# 6. 두 기계어 명령어 구조 diff 검증
86echo "[6/6] Verifying assembly structural integrity via diff..."
87echo "------------------------------------------------------------"
88if diff orig_pure.asm asm_pure.asm > /dev/null; then
89 echo "===> [성공] 두 바이너리의 main.main 기계어 로직이 100% 일치합니다! <==="
90 echo "컴파일러의 최적화 파이프라인 가이드라인을 완벽하게 동기화하여 동일한 어셈블리를 얻었습니다."
91else
92 echo "===> [실패] 어셈블리 명령어 구조에 차이점이 발견되었습니다. <==="
93 diff -u orig_pure.asm asm_pure.asm
94fi
95echo "------------------------------------------------------------"
Betiği gerçekten çalıştırdığınızda, aşağıdaki çıktıyı elde edersiniz.
1[1/6] Cleaning up old artifacts...
2[2/6] Generating main.go...
3[3/6] Generating main_from_asm.go...
4[4/6] Compiling both sources inside 'test_dir'...
5[5/6] Extracting main.main assembly sections...
6[6/6] Verifying assembly structural integrity via diff...
7------------------------------------------------------------
8===> [성공] 두 바이너리의 main.main 기계어 로직이 100% 일치합니다! <===
9컴파일러의 최적화 파이프라인 가이드라인을 완벽하게 동기화하여 동일한 어셈블리를 얻었습니다.
10------------------------------------------------------------
Sonuç
Programlama dilleri birçok soyutlama sunar; ancak bu soyutlamaların ardında çok ilginç ve agresif optimizasyonların gizli olduğu görülmüştür. Ayrıca bu durumdan yararlanarak, kaynak kodları farklı olsa bile assembly'si aynı olan ayna görüntülü kodlar da üretilebilmiştir. Düşük seviyeye ilgi duyuyorsanız ve Go ile yazılmış kapalı kaynaklı bir yazılımla karşılaşırsanız, assembly'yi doğrudan ayrıştırıp analiz ederek kaynak kodunu geri kazanmak da imkânsız görünmemektedir.
Sonraki Ders
Bir sonraki derste, If deyimi ile birlikte başka bir ilgi çekici konu olan select-case deyimini inceleyeceğiz.