์ปดํ์ผ๋ฌ๋ฅผ ๊ฐ๋ฐํ๋ ๊ฒ์ ๋งค์ฐ ์ด๋ ค์ด ์์
์
๋๋ค. ๊ทธ๋ฌ๋ ๋คํ์ค๋ฝ๊ฒ๋ LLVM๊ณผ ๊ฐ์ ํ๋ก์ ํธ์ ๊ฐ๋ฐ๋ก ์ด ๋ฌธ์ ์ ๋ํ ํด๊ฒฐ์ฑ
์ด ํฌ๊ฒ ๋จ์ํ๋์ด ๋จ์ผ ํ๋ก๊ทธ๋๋จธ๋ผ๋ ์ฑ๋ฅ์ด C์ ๊ฐ๊น์ด ์๋ก์ด ์ธ์ด๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค. ์์คํ
์ ๋ฌธ์๊ฐ ๊ฑฐ์ ์๋ ์์ฒญ๋ ์์ ์ฝ๋๋ก ํํ๋ฉ๋๋ค. ์ด๋ฌํ ๋จ์ ์ ๋ฐ๋ก์ก๊ธฐ ์ํด ์ค๋ ์ฐ๋ฆฌ๊ฐ ๋ฒ์ญํ ์๋ฃ์ ์ ์๋ Go๋ก ์์ฑ๋ ์ฝ๋์ ์๋ฅผ ๋ณด์ฌ์ฃผ๊ณ ์ด๊ฒ์ด ์ฒ์์ผ๋ก ์ด๋ป๊ฒ ๋ฒ์ญ๋๋์ง ๋ณด์ฌ์ค ๊ฒ์
๋๋ค.
์ฒซ ๋ฒ์งธ ์
์ฌ๊ธฐ์ ์ดํด๋ณผ ์ฒซ ๋ฒ์งธ ํจ์๋ ์ซ์๋ฅผ ์ถ๊ฐํ๋ ๊ฐ๋จํ ๋ฉ์ปค๋์ฆ์ ๋๋ค.
func myAdd(a, b int) int{
return a + b
}
์ด ๊ธฐ๋ฅ์ ๋งค์ฐ ๊ฐ๋จํ๋ฉฐ ์๋ง๋ ์ด๋ณด๋ค ๋ ๊ฐ๋จํ ๊ฒ์ ์์ ๊ฒ์ ๋๋ค. ์ด๋ ๋ค์ Go SSA ์ฝ๋๋ก ๋ณํ๋ฉ๋๋ค.
func myAdd(a int, b int) int:
entry:
t0 = a + b int
return t0
์ด ๋ณด๊ธฐ๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐ์ดํฐ ์ ํ ํํธ๊ฐ ์ค๋ฅธ์ชฝ์ ๋ฐฐ์น๋๋ฉฐ ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ๋ฌด์ํ ์ ์์ต๋๋ค.
์ด ์์ ์๋ฅผ ํตํด ์ด๋ฏธ SSA์ ํ ์ธก๋ฉด์ ๋ณธ์ง์ ๋ณผ ์ ์์ต๋๋ค. ์ฆ, ์ฝ๋๋ฅผ SSA ํ์์ผ๋ก ๋ณํํ ๋ ๊ฐ ํํ์์ ๊ตฌ์ฑ๋๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ถ๋ถ์ผ๋ก ๊ตฌ๋ถ๋ฉ๋๋ค. ์ฐ๋ฆฌ์ ๊ฒฝ์ฐ ๋ช
๋ น์ return a + b
๋ ์ค์ ๋ก ๋ ๊ฐ์ ์ซ์๋ฅผ ๋ํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ๋ ๊ฐ์ง ์์
์ ๋ํ๋
๋๋ค.
๋ํ ์ฌ๊ธฐ์๋ ํ๋ก๊ทธ๋จ์ ๊ธฐ๋ณธ ๋ธ๋ก์ ๋ณผ ์ ์์ผ๋ฉฐ, ์ด ์ฝ๋์๋ ์ ๋ ฅ ๋ธ๋ก์ด๋ผ๋ ๋จ ํ๋์ ๋ธ๋ก๋ง ์์ต๋๋ค. ์๋์์ ๋ธ๋ก์ ๋ํด ๋ ์์ธํ ์ด์ผ๊ธฐํ๊ฒ ์ต๋๋ค.
Go SSA ์ฝ๋๋ LLVM IR๋ก ์ฝ๊ฒ ๋ณํ๋ฉ๋๋ค.
define i64 @myAdd(i64 %a, i64 %b) {
entry:
%0 = add i64 %a, %b
ret i64 %0
}
์ฌ๊ธฐ์ ์ ์ ์๋ ๊ฒ์ ๋ค์ํ ๊ตฌ๋ฌธ ๊ตฌ์กฐ๊ฐ ์ฌ์ฉ๋๋๋ผ๋ ํจ์์ ๊ตฌ์กฐ๋ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ณ๊ฒฝ๋์ง ์๋๋ค๋ ๊ฒ์
๋๋ค. LLVM IR ์ฝ๋๋ C์ ์ ์ฌํ๊ฒ Go SSA ์ฝ๋๋ณด๋ค ์ฝ๊ฐ ๋ ๊ฐ๋ ฅํฉ๋๋ค. ์ฌ๊ธฐ์ ํจ์ ์ ์ธ์๋ ๋จผ์ ๋ฐํํ๋ ๋ฐ์ดํฐ ์ ํ์ ๋ํ ์ค๋ช
์ด ์์ผ๋ฉฐ ์ธ์ ์ ํ์ ์ธ์ ์ด๋ฆ ์์ ํ์๋ฉ๋๋ค. ๋ํ IR ๊ตฌ๋ฌธ ๋ถ์์ ๋จ์ํํ๊ธฐ ์ํด ์ ์ญ ์ํฐํฐ ์ด๋ฆ ์์ ๊ธฐํธ๊ฐ ๋ถ์ต๋๋ค. @
, ์ง์ญ ์ด๋ฆ ์์ ๊ธฐํธ๊ฐ ์์ต๋๋ค %
(ํจ์๋ ์ ์ญ ์ํฐํฐ๋ก๋ ๊ฐ์ฃผ๋ฉ๋๋ค).
์ด ์ฝ๋์์ ์ฃผ๋ชฉํด์ผ ํ ์ ์ Go์ ์ ํ ํํ ๊ฒฐ์ ์ด int
์ปดํ์ผ๋ฌ์ ์ปดํ์ผ ๋์์ ๋ฐ๋ผ 32๋นํธ ๋๋ 64๋นํธ ๊ฐ์ผ๋ก ํ์๋ ์ ์๋ ๋ LLVM์ด IR ์ฝ๋๋ฅผ ์์ฑํ ๋ ํ์ฉ๋ฉ๋๋ค. ์ด๋ ๋ง์ ์ฌ๋๋ค์ด ์๊ฐํ๋ ๊ฒ์ฒ๋ผ LLVM IR ์ฝ๋๊ฐ ํ๋ซํผ ๋
๋ฆฝ์ ์ด์ง ์์ ๋ง์ ์ด์ ์ค ํ๋์
๋๋ค. ํ ํ๋ซํผ์ฉ์ผ๋ก ์์ฑ๋ ์ด๋ฌํ ์ฝ๋๋ ๋ค๋ฅธ ํ๋ซํผ์ฉ์ผ๋ก ๊ฐ๋จํ ๊ฐ์ ธ์์ ์ปดํ์ผํ ์ ์์ต๋๋ค(์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ ์ ํฉํ์ง ์์ ํ).
์ฃผ๋ชฉํ ๋งํ ๋ ๋ค๋ฅธ ํฅ๋ฏธ๋ก์ด ์ ์ ์ ํ์ด i64
๋ถํธ ์๋ ์ ์๊ฐ ์๋๋๋ค. ์ซ์์ ๋ถํธ๋ฅผ ๋ํ๋ด๋ ์ธก๋ฉด์์ ์ค๋ฆฝ์ ์
๋๋ค. ๋ช
๋ น์ด์ ๋ฐ๋ผ ๋ถํธ ์๋ ์ซ์์ ๋ถํธ ์๋ ์ซ์๋ฅผ ๋ชจ๋ ๋ํ๋ผ ์ ์์ต๋๋ค. ๋ง์
์ฐ์ฐ์ ํํ์ ๊ฒฝ์ฐ์๋ ์ด๊ฒ์ด ์ค์ํ์ง ์์ผ๋ฏ๋ก ๋ถํธ ์๋ ์ซ์๋ ๋ถํธ ์๋ ์ซ์๋ก ์์
ํ๋๋ฐ ์ฐจ์ด๊ฐ ์์ต๋๋ค. ์ฌ๊ธฐ์๋ C ์ธ์ด์์ ๋ถํธ ์๋ ์ ์ ๋ณ์๋ฅผ ์ค๋ฒํ๋กํ๋ฉด ์ ์๋์ง ์์ ๋์์ด ๋ฐ์ํ๋ฏ๋ก Clang ํ๋ฐํธ์๋๊ฐ ์์
์ ํ๋๊ทธ๋ฅผ ์ถ๊ฐํ๋ค๋ ์ ์ ์ฃผ๋ชฉํ๊ณ ์ถ์ต๋๋ค. nsw
(์๋ช
๋ ๋ฉ ์์) ์ด๋ ์ถ๊ฐ๊ฐ ์ค๋ฒํ๋ก๋์ง ์๋๋ค๊ณ ๊ฐ์ ํ ์ ์์์ LLVM์ ์๋ ค์ค๋๋ค.
์ด๋ ์ผ๋ถ ์ต์ ํ์ ์ค์ํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ๋ ๊ฐ์ ๊ฐ์ ์ถ๊ฐํ๋ฉด i16
32๋นํธ ํ๋ซํผ(32๋นํธ ๋ ์ง์คํฐ ์ฌ์ฉ)์์๋ ์ถ๊ฐ ํ ๋ฒ์ ๋ด์ ์ ์งํ๊ธฐ ์ํด ๋ถํธ ํ์ฅ ์์
์ด ํ์ํฉ๋๋ค. i16
. ์ด ๋๋ฌธ์ ๊ธฐ๊ณ ๋ ์ง์คํฐ ํฌ๊ธฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ ์ ์ฐ์ฐ์ ์ํํ๋ ๊ฒ์ด ๋ ํจ์จ์ ์ธ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค.
์ด IR ์ฝ๋๋ก ๋ค์์ ๋ฌด์จ ์ผ์ด ์ผ์ด๋ ์ง๋ ํ์ฌ ์ฐ๋ฆฌ์๊ฒ ํน๋ณํ ๊ด์ฌ์ด ์๋๋๋ค. ์ฝ๋๋ ์ต์ ํ๋ ๋ค์(๊ทธ๋ฌ๋ ์ฐ๋ฆฌ์ ๊ฐ์ ๊ฐ๋จํ ์์ ์ ๊ฒฝ์ฐ ์๋ฌด๊ฒ๋ ์ต์ ํ๋์ง ์์) ๊ธฐ๊ณ์ด ์ฝ๋๋ก ๋ณํ๋ฉ๋๋ค.
๋ ๋ฒ์งธ ์
์ฐ๋ฆฌ๊ฐ ์ดํด๋ณผ ๋ค์ ์๋ ์ข ๋ ๋ณต์กํ ๊ฒ์ ๋๋ค. ์ฆ, ์ฐ๋ฆฌ๋ ์ ์ ์กฐ๊ฐ์ ํฉํ๋ ํจ์์ ๋ํด ์ด์ผ๊ธฐํ๊ณ ์์ต๋๋ค.
func sum(numbers []int) int {
n := 0
for i := 0; i < len(numbers); i++ {
n += numbers[i]
}
return n
}
์ด ์ฝ๋๋ ๋ค์ Go SSA ์ฝ๋๋ก ๋ณํ๋ฉ๋๋ค.
func sum(numbers []int) int:
entry:
jump for.loop
for.loop:
t0 = phi [entry: 0:int, for.body: t6] #n int
t1 = phi [entry: 0:int, for.body: t7] #i int
t2 = len(numbers) int
t3 = t1 < t2 bool
if t3 goto for.body else for.done
for.body:
t4 = &numbers[t1] *int
t5 = *t4 int
t6 = t0 + t5 int
t7 = t1 + 1:int int
jump for.loop
for.done:
return t0
์ฌ๊ธฐ์๋ SSA ํ์์ผ๋ก ์ฝ๋๋ฅผ ํํํ๋ ์ผ๋ฐ์ ์ธ ๊ตฌ์ฑ์ ๋ ๋ง์ด ๋ณผ ์ ์์ต๋๋ค. ์๋ง๋ ์ด ์ฝ๋์ ๊ฐ์ฅ ๋ถ๋ช ํ ํน์ง์ ๊ตฌ์กฐํ๋ ํ๋ฆ ์ ์ด ๋ช ๋ น์ด ์๋ค๋ ์ฌ์ค์ผ ๊ฒ์ ๋๋ค. ๊ณ์ฐ์ ํ๋ฆ์ ์ ์ดํ๋ ค๋ฉด ์กฐ๊ฑด๋ถ ์ ํ์ ๋ฌด์กฐ๊ฑด ์ ํ๋ง ์๊ณ , ์ด ๋ช ๋ น์ ํ๋ฆ ์ ์ด ๋ช ๋ น์ผ๋ก ๊ฐ์ฃผํ๋ฉด ๋ฐํ ๋ช ๋ น์ด ์์ต๋๋ค.
์ค์ ๋ก ์ฌ๊ธฐ์๋ ํ๋ก๊ทธ๋จ์ด ์ค๊ดํธ๋ฅผ ์ฌ์ฉํ์ฌ ๋ธ๋ก์ผ๋ก ๊ตฌ๋ถ๋์ง ์๋๋ค๋ ์ฌ์ค์ ์ฃผ๋ชฉํ ์ ์์ต๋๋ค(C ์ธ์ด ๊ณ์ด์์์ ๊ฐ์ด). ์ด์
๋ธ๋ฆฌ ์ธ์ด๋ฅผ ์ฐ์์ํค๋ ๋ผ๋ฒจ๋ณ๋ก ๋๋์ด ๊ธฐ๋ณธ ๋ธ๋ก ํํ๋ก ํํ๋์ด ์์ต๋๋ค. SSA์์ ๊ธฐ๋ณธ ๋ธ๋ก์ ๋ ์ด๋ธ๋ก ์์ํ๊ณ ๊ธฐ๋ณธ ๋ธ๋ก ์์ฑ ๋ช
๋ น์ผ๋ก ๋๋๋ ์ฐ์์ ์ธ ์ฝ๋ ์ํ์ค๋ก ์ ์๋ฉ๋๋ค. return
ะธ jump
.
์ด ์ฝ๋์ ๋ ๋ค๋ฅธ ํฅ๋ฏธ๋ก์ด ์ธ๋ถ ์ฌํญ์ ๋ค์ ๋ช
๋ น์ด๋ก ํํ๋ฉ๋๋ค. phi
. ์ง์นจ์ ๋งค์ฐ ํน์ดํ๋ฉฐ ์ดํดํ๋ ๋ฐ ์๊ฐ์ด ๊ฑธ๋ฆด ์ ์์ต๋๋ค. ๊ธฐ์ต myAdd
์์ ๋์ ์์ง๋ง ์ด ์น์
์์ ์ค๋ช
ํ๋ ํจ์์ ๊ฐ์ ๋ ๋ณต์กํ ํจ์์๋ ์ ํฉํ์ง ์์ต๋๋ค. sum
. ํนํ ๋ฃจํ ์คํ ์ค์ ๋ณ์๊ฐ ๋ณ๊ฒฝ๋ฉ๋๋ค. i
ะธ n
.
SSA๋ ์์ ๋ช
๋ น์ด๋ฅผ ์ฌ์ฉํ์ฌ ๋ณ์ ๊ฐ์ ํ ๋ฒ ํ ๋นํ๋ ์ ํ์ ์ฐํํฉ๋๋ค. phi
(๊ทธ ์ด๋ฆ์ ๊ทธ๋ฆฌ์ค ์ํ๋ฒณ์์ ๋ฐ์์ต๋๋ค). ์ฌ์ค C์ ๊ฐ์ ์ธ์ด์ ๋ํด SSA ์ฝ๋ ํํ์ ์์ฑํ๋ ค๋ฉด ๋ช ๊ฐ์ง ํธ๋ฆญ์ ์ฌ์ฉํด์ผ ํฉ๋๋ค. ์ด ๋ช
๋ น์ด๋ฅผ ํธ์ถํ ๊ฒฐ๊ณผ๋ ๋ณ์์ ํ์ฌ ๊ฐ(i
๋๋ n
), ๊ธฐ๋ณธ ๋ธ๋ก์ ๋ชฉ๋ก์ด ๋งค๊ฐ๋ณ์๋ก ์ฌ์ฉ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ค์ ์ง์นจ์ ๊ณ ๋ คํด๋ณด์ธ์.
t0 = phi [entry: 0:int, for.body: t6] #n
๊ทธ ์๋ฏธ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค. ์ด์ ๊ธฐ๋ณธ ๋ธ๋ก์ด ๋ธ๋ก์ด์๋ ๊ฒฝ์ฐ entry
(์
๋ ฅ), ๊ทธ๋ฐ ๋ค์ t0
์์์ด๋ค 0
, ๊ทธ๋ฆฌ๊ณ ์ด์ ๊ธฐ๋ณธ ๋ธ๋ก์ด for.body
, ๊ทธ๋ฐ ๋ค์ ๊ฐ์ ๊ฐ์ ธ์์ผ ํฉ๋๋ค. t6
์ด ๋ธ๋ก์์. ์ด ๋ชจ๋ ๊ฒ์ด ๋งค์ฐ ์ ๋น์ค๋ฌ์ ๋ณด์ผ ์ ์์ง๋ง ์ด ๋ฉ์ปค๋์ฆ์ด SSA๋ฅผ ์๋ํ๊ฒ ๋ง๋๋ ๊ฒ์
๋๋ค. ์ธ๊ฐ์ ๊ด์ ์์ ๋ณด๋ฉด ์ด ๋ชจ๋ ๊ฒ์ด ์ฝ๋๋ฅผ ์ดํดํ๊ธฐ ์ด๋ ต๊ฒ ๋ง๋ญ๋๋ค. ๊ทธ๋ฌ๋ ๊ฐ ๊ฐ์ด ํ ๋ฒ๋ง ํ ๋น๋๋ค๋ ์ฌ์ค์ ๋ง์ ์ต์ ํ๋ฅผ ํจ์ฌ ์ฝ๊ฒ ๋ง๋ญ๋๋ค.
์์ ๋ง์ ์ปดํ์ผ๋ฌ๋ฅผ ์์ฑํ๋ฉด ์ผ๋ฐ์ ์ผ๋ก ์ด๋ฐ ์ข
๋ฅ์ ์์
์ ์ฒ๋ฆฌํ ํ์๊ฐ ์์ต๋๋ค. Clang์กฐ์ฐจ๋ ์ด๋ฌํ ๋ช
๋ น์ด๋ฅผ ๋ชจ๋ ์์ฑํ์ง๋ ์์ต๋๋ค. phi
, ๋ฉ์ปค๋์ฆ์ ์ฌ์ฉํฉ๋๋ค alloca
(์ผ๋ฐ์ ์ธ ์ง์ญ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๊ณผ ์ ์ฌํฉ๋๋ค). ๊ทธ๋ฐ ๋ค์ LLVM ์ต์ ํ ํจ์ค๋ฅผ ์คํํ ๋ alloca
SSA ํ์์ผ๋ก ๋ณํ๋ฉ๋๋ค. ๊ทธ๋ฌ๋ TinyGo๋ ํธ๋ฆฌํ๊ฒ๋ ์ด๋ฏธ SSA ํ์์ผ๋ก ๋ณํ๋ Go SSA๋ก๋ถํฐ ์
๋ ฅ์ ๋ฐ์ต๋๋ค.
๊ณ ๋ ค ์ค์ธ ์ค๊ฐ ์ฝ๋ ์กฐ๊ฐ์ ๋ ๋ค๋ฅธ ํ์ ์ ์ธ๋ฑ์ค์ ์ํ ์ฌ๋ผ์ด์ค ์์์ ๋ํ ์ก์ธ์ค๊ฐ ์ฃผ์๋ฅผ ๊ณ์ฐํ๋ ์์
๊ณผ ๊ฒฐ๊ณผ ํฌ์ธํฐ๋ฅผ ์ญ์ฐธ์กฐํ๋ ์์
์ ํํ๋ก ํํ๋๋ค๋ ๊ฒ์
๋๋ค. ์ฌ๊ธฐ์๋ IR ์ฝ๋์ ์์๊ฐ ์ง์ ์ถ๊ฐ๋๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค(์: - 1:int
). ํจ์๊ฐ ํฌํจ๋ ์์์ myAdd
์ด๊ฒ์ ์ฌ์ฉ๋์ง ์์์ต๋๋ค. ์ด์ ์ด๋ฌํ ๊ธฐ๋ฅ์ ์ ๊ฑฐํ์ผ๋ฏ๋ก ์ด ์ฝ๋๊ฐ LLVM IR ํ์์ผ๋ก ๋ณํ๋๋ฉด ์ด๋ป๊ฒ ๋๋์ง ์ดํด๋ณด๊ฒ ์ต๋๋ค.
define i64 @sum(i64* %ptr, i64 %len, i64 %cap) {
entry:
br label %for.loop
for.loop: ; preds = %for.body, %entry
%0 = phi i64 [ 0, %entry ], [ %5, %deref.next ]
%1 = phi i64 [ 0, %entry ], [ %6, %deref.next ]
%2 = icmp slt i64 %1, %len
br i1 %2, label %for.body, label %for.done
for.body: ; preds = %for.loop
%3 = getelementptr i64, i64* %ptr, i64 %1
%4 = load i64, i64* %3
%5 = add i64 %0, %4
%6 = add i64 %1, 1
br label %for.loop
for.done: ; preds = %for.loop
ret i64 %0
}
์ฌ๊ธฐ์๋ ์ด์ ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ค๋ฅธ ๊ตฌ๋ฌธ ๊ตฌ์กฐ๋ฅผ ํฌํจํ๋ ๋์ผํ ๊ตฌ์กฐ๋ฅผ ๋ณผ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ํตํ ์ค phi
๊ฐ๊ณผ ๋ผ๋ฒจ์ด ๋ฐ๋์์ต๋๋ค. ๊ทธ๋ฐ๋ฐ ์ฌ๊ธฐ์ ํน๋ณํ ์ฃผ๋ชฉํด์ผ ํ ์ ์ด ์๋ค.
์ฐ์ ์ฌ๊ธฐ์์ ์์ ํ ๋ค๋ฅธ ๊ธฐ๋ฅ ์๋ช
์ ๋ณผ ์ ์์ต๋๋ค. LLVM์ ์ฌ๋ผ์ด์ค๋ฅผ ์ง์ํ์ง ์์ผ๋ฉฐ ๊ฒฐ๊ณผ์ ์ผ๋ก ์ต์ ํ๋ฅผ ์ํด ์ด ์ค๊ฐ ์ฝ๋๋ฅผ ์์ฑํ TinyGo ์ปดํ์ผ๋ฌ๋ ์ด ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ๋ํ ์ค๋ช
์ ์ฌ๋ฌ ๋ถ๋ถ์ผ๋ก ๋ถํ ํ์ต๋๋ค. ์ด๋ ์ธ ๊ฐ์ ์ฌ๋ผ์ด์ค ์์๋ฅผ ๋ํ๋ผ ์ ์์ต๋๋ค(ptr
, len
ะธ cap
)๋ฅผ ๊ตฌ์กฐ(struct)๋ก ๋ํ๋ด์ง๋ง ์ด๋ฅผ ์ธ ๊ฐ์ ๋ณ๋ ์ํฐํฐ๋ก ํ์ํ๋ฉด ์ผ๋ถ ์ต์ ํ๊ฐ ๊ฐ๋ฅํฉ๋๋ค. ๋ค๋ฅธ ์ปดํ์ผ๋ฌ๋ ๋์ ํ๋ซํผ ํจ์์ ํธ์ถ ๊ท์น์ ๋ฐ๋ผ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ์ฌ๋ผ์ด์ค๋ฅผ ๋ํ๋ผ ์ ์์ต๋๋ค.
์ด ์ฝ๋์ ๋ ๋ค๋ฅธ ํฅ๋ฏธ๋ก์ด ํน์ง์ ๋ช
๋ น์ด๋ฅผ ์ฌ์ฉํ๋ค๋ ๊ฒ์
๋๋ค. getelementptr
(ํํ GEP๋ก ์ฝ์นญํจ)
์ด ๋ช ๋ น์ด๋ ํฌ์ธํฐ์ ํจ๊ป ์๋ํ๋ฉฐ ์ฌ๋ผ์ด์ค ์์์ ๋ํ ํฌ์ธํฐ๋ฅผ ์ป๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด C๋ก ์์ฑ๋ ๋ค์ ์ฝ๋์ ๋น๊ตํด ๋ณด๊ฒ ์ต๋๋ค.
int* sliceptr(int *ptr, int index) {
return &ptr[index];
}
๋๋ ๋ค์๊ณผ ๋์ผํฉ๋๋ค.
int* sliceptr(int *ptr, int index) {
return ptr + index;
}
์ฌ๊ธฐ์ ๊ฐ์ฅ ์ค์ํ ๊ฒ์ ์ง์นจ์
๋๋ค. getelementptr
์ญ์ฐธ์กฐ ์์
์ ์ํํ์ง ์์ต๋๋ค. ๋จ์ง ๊ธฐ์กด ํฌ์ธํฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ ํฌ์ธํฐ๋ฅผ ๊ณ์ฐํฉ๋๋ค. ์ง์นจ์ผ๋ก ๋ฐ์ ๋ค์ผ ์ ์์ต๋๋ค. mul
ะธ add
ํ๋์จ์ด ์์ค์์. GEP ์ง์นจ์ ๋ํด ์์ธํ ์์๋ณผ ์ ์์ต๋๋ค.
์ด ์ค๊ฐ ์ฝ๋์ ๋ ๋ค๋ฅธ ํฅ๋ฏธ๋ก์ด ํน์ง์ ๋ช
๋ น์ด๋ฅผ ์ฌ์ฉํ๋ค๋ ๊ฒ์
๋๋ค. icmp
. ์ด๋ ์ ์ ๋น๊ต๋ฅผ ๊ตฌํํ๋ ๋ฐ ์ฌ์ฉ๋๋ ๋ฒ์ฉ ๋ช
๋ น์ด์
๋๋ค. ์ด ๋ช
๋ น์ด์ ๊ฒฐ๊ณผ๋ ํญ์ ์ ํ์ ๊ฐ์
๋๋ค. i1
โ ๋
ผ๋ฆฌ๊ฐ. ์ด ๊ฒฝ์ฐ ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋น๊ต๊ฐ ์ด๋ฃจ์ด์ง๋๋ค. slt
(๋ณด๋ค ์๊ฒ ๋ถํธ ์์), ์ด์ ์ ์ ํ์ผ๋ก ํ์๋์๋ ๋ ์ซ์๋ฅผ ๋น๊ตํ๊ณ ์๊ธฐ ๋๋ฌธ์
๋๋ค. int
. ๋ ๊ฐ์ ๋ถํธ ์๋ ์ ์๋ฅผ ๋น๊ตํ๋ ๊ฒฝ์ฐ ๋ค์์ ์ฌ์ฉํฉ๋๋ค. icmp
, ๋น๊ต์ ์ฌ์ฉ๋ ํค์๋๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค. ult
. ๋ถ๋ ์์์ ์ซ์๋ฅผ ๋น๊ตํ๋ ค๋ฉด ๋ค๋ฅธ ๋ช
๋ น์ด๊ฐ ์ฌ์ฉ๋ฉ๋๋ค. fcmp
, ๋น์ทํ ๋ฐฉ์์ผ๋ก ์๋ํฉ๋๋ค.
๊ฒฐ๊ณผ
๋๋ ์ด ์๋ฃ์์ LLVM IR์ ๊ฐ์ฅ ์ค์ํ ๊ธฐ๋ฅ์ ๋ค๋ฃจ์๋ค๊ณ ๋ฏฟ์ต๋๋ค. ๋ฌผ๋ก ์ฌ๊ธฐ์๋ ๋ ๋ง์ ๊ฒ์ด ์์ต๋๋ค. ํนํ, ์ฝ๋์ ์ค๊ฐ ํํ์๋ IR์์ ๋ฌ๋ฆฌ ํํํ ์ ์๋ ์ปดํ์ผ๋ฌ์ ์๋ ค์ง ์ฝ๋์ ํน์ ๊ธฐ๋ฅ์ ๊ณ ๋ คํ๊ธฐ ์ํ ์ต์ ํ ํจ์ค๋ฅผ ํ์ฉํ๋ ๋ง์ ์ฃผ์์ด ํฌํจ๋ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ์ด๊ฒ์ ํ๋๊ทธ์
๋๋ค. inbounds
GEP ๋ช
๋ น ๋๋ ํ๋๊ทธ nsw
ะธ nuw
, ์ง์นจ์ ์ถ๊ฐํ ์ ์์ add
. ํค์๋๋ ๋ง์ฐฌ๊ฐ์ง private
, ํ์ํ๋ ํจ์๊ฐ ํ์ฌ ์ปดํ์ผ ๋จ์ ์ธ๋ถ์์ ์ฐธ์กฐ๋์ง ์์์ ์ต์ ํ ํ๋ก๊ทธ๋จ์ ๋ํ๋
๋๋ค. ์ด๋ฅผ ํตํด ์ฌ์ฉ๋์ง ์๋ ์ธ์ ์ ๊ฑฐ์ ๊ฐ์ ํฅ๋ฏธ๋ก์ด ํ๋ก์์ ๊ฐ ์ต์ ํ๊ฐ ๊ฐ๋ฅํด์ง๋๋ค.
LLVM์ ๋ํ ์์ธํ ๋ด์ฉ์ ๋ค์์์ ํ์ธํ ์ ์์ต๋๋ค.
๋ ์ ์ฌ๋ฌ๋ถ! LLVM์ ์ฌ์ฉํ๊ณ ์๋์?
์ถ์ฒ : habr.com