ਇੱਕ ਗੋ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ LLVM

ਕੰਪਾਈਲਰ ਦਾ ਵਿਕਾਸ ਕਰਨਾ ਬਹੁਤ ਔਖਾ ਕੰਮ ਹੈ। ਪਰ, ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, LLVM ਵਰਗੇ ਪ੍ਰੋਜੈਕਟਾਂ ਦੇ ਵਿਕਾਸ ਦੇ ਨਾਲ, ਇਸ ਸਮੱਸਿਆ ਦੇ ਹੱਲ ਨੂੰ ਬਹੁਤ ਸਰਲ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਸਿੰਗਲ ਪ੍ਰੋਗਰਾਮਰ ਨੂੰ ਇੱਕ ਨਵੀਂ ਭਾਸ਼ਾ ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜੋ C ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਨੇੜੇ ਹੈ। LLVM ਨਾਲ ਕੰਮ ਕਰਨਾ ਇਸ ਤੱਥ ਦੁਆਰਾ ਗੁੰਝਲਦਾਰ ਹੈ ਕਿ ਇਹ ਸਿਸਟਮ ਨੂੰ ਕੋਡ ਦੀ ਇੱਕ ਵੱਡੀ ਮਾਤਰਾ ਦੁਆਰਾ ਦਰਸਾਇਆ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਬਹੁਤ ਘੱਟ ਦਸਤਾਵੇਜ਼ਾਂ ਨਾਲ ਲੈਸ ਹੈ। ਇਸ ਕਮੀ ਨੂੰ ਠੀਕ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਲਈ, ਸਮੱਗਰੀ ਦਾ ਲੇਖਕ, ਜਿਸਦਾ ਅਨੁਵਾਦ ਅਸੀਂ ਅੱਜ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰ ਰਹੇ ਹਾਂ, ਗੋ ਵਿੱਚ ਲਿਖੇ ਕੋਡ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦਿਖਾਉਣ ਜਾ ਰਿਹਾ ਹੈ ਅਤੇ ਇਹ ਦਿਖਾਉਣ ਜਾ ਰਿਹਾ ਹੈ ਕਿ ਉਹਨਾਂ ਦਾ ਪਹਿਲੀ ਵਾਰ ਅਨੁਵਾਦ ਕਿਵੇਂ ਕੀਤਾ ਗਿਆ ਸੀ। ਜਾਓ SSA, ਅਤੇ ਫਿਰ ਕੰਪਾਈਲਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ LLVM IR ਵਿੱਚ ਟਿੰਨੀਗੋ. Go SSA ਅਤੇ LLVM IR ਕੋਡ ਨੂੰ ਉਹਨਾਂ ਚੀਜ਼ਾਂ ਨੂੰ ਹਟਾਉਣ ਲਈ ਥੋੜ੍ਹਾ ਸੰਪਾਦਿਤ ਕੀਤਾ ਗਿਆ ਹੈ ਜੋ ਇੱਥੇ ਦਿੱਤੇ ਗਏ ਸਪੱਸ਼ਟੀਕਰਨਾਂ ਨਾਲ ਸੰਬੰਧਿਤ ਨਹੀਂ ਹਨ, ਤਾਂ ਜੋ ਸਪੱਸ਼ਟੀਕਰਨਾਂ ਨੂੰ ਹੋਰ ਸਮਝਣ ਯੋਗ ਬਣਾਇਆ ਜਾ ਸਕੇ।

ਪਹਿਲੀ ਉਦਾਹਰਨ

ਪਹਿਲਾ ਫੰਕਸ਼ਨ ਜੋ ਮੈਂ ਇੱਥੇ ਦੇਖਣ ਜਾ ਰਿਹਾ ਹਾਂ ਨੰਬਰ ਜੋੜਨ ਲਈ ਇੱਕ ਸਧਾਰਨ ਵਿਧੀ ਹੈ:

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 ਕੋਡ Go SSA ਕੋਡ ਨਾਲੋਂ ਥੋੜਾ ਮਜ਼ਬੂਤ ​​ਹੈ, C ਦੇ ਸਮਾਨ ਹੈ। ਇੱਥੇ, ਫੰਕਸ਼ਨ ਘੋਸ਼ਣਾ ਵਿੱਚ, ਪਹਿਲਾਂ ਉਸ ਡੇਟਾ ਕਿਸਮ ਦਾ ਵਰਣਨ ਹੁੰਦਾ ਹੈ ਜੋ ਇਹ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਆਰਗੂਮੈਂਟ ਨਾਮ ਤੋਂ ਪਹਿਲਾਂ ਆਰਗੂਮੈਂਟ ਕਿਸਮ ਦਰਸਾਈ ਜਾਂਦੀ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, IR ਪਾਰਸਿੰਗ ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਲਈ, ਗਲੋਬਲ ਇਕਾਈਆਂ ਦੇ ਨਾਮ ਚਿੰਨ੍ਹ ਤੋਂ ਪਹਿਲਾਂ ਹਨ @, ਅਤੇ ਸਥਾਨਕ ਨਾਵਾਂ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਚਿੰਨ੍ਹ ਹੈ % (ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ ਗਲੋਬਲ ਇਕਾਈ ਵੀ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ)।

ਇਸ ਕੋਡ ਬਾਰੇ ਧਿਆਨ ਦੇਣ ਵਾਲੀ ਗੱਲ ਇਹ ਹੈ ਕਿ ਗੋ ਦੀ ਕਿਸਮ ਪ੍ਰਤੀਨਿਧਤਾ ਦਾ ਫੈਸਲਾ int, ਜਿਸ ਨੂੰ ਕੰਪਾਈਲਰ ਅਤੇ ਕੰਪਾਈਲੇਸ਼ਨ ਦੇ ਟੀਚੇ ਦੇ ਆਧਾਰ 'ਤੇ 32-ਬਿੱਟ ਜਾਂ 64-ਬਿੱਟ ਮੁੱਲ ਦੇ ਤੌਰ 'ਤੇ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਦੋਂ LLVM IR ਕੋਡ ਤਿਆਰ ਕਰਦਾ ਹੈ ਤਾਂ ਸਵੀਕਾਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਬਹੁਤ ਸਾਰੇ ਕਾਰਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਕਿ LLVM IR ਕੋਡ ਨਹੀਂ ਹੈ, ਜਿਵੇਂ ਕਿ ਬਹੁਤ ਸਾਰੇ ਲੋਕ ਸੋਚਦੇ ਹਨ, ਪਲੇਟਫਾਰਮ ਸੁਤੰਤਰ ਹੈ। ਅਜਿਹਾ ਕੋਡ, ਇੱਕ ਪਲੇਟਫਾਰਮ ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ, ਨੂੰ ਸਿਰਫ਼ ਦੂਜੇ ਪਲੇਟਫਾਰਮ ਲਈ ਲਿਆ ਜਾਂ ਕੰਪਾਇਲ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ (ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਢੁਕਵੇਂ ਨਹੀਂ ਹੋ। ਬਹੁਤ ਜ਼ਿਆਦਾ ਦੇਖਭਾਲ ਦੇ ਨਾਲ).

ਧਿਆਨ ਦੇਣ ਯੋਗ ਇਕ ਹੋਰ ਦਿਲਚਸਪ ਨੁਕਤਾ ਇਹ ਹੈ ਕਿ ਕਿਸਮ i64 ਇੱਕ ਹਸਤਾਖਰਿਤ ਪੂਰਨ ਅੰਕ ਨਹੀਂ ਹੈ: ਇਹ ਸੰਖਿਆ ਦੇ ਚਿੰਨ੍ਹ ਨੂੰ ਦਰਸਾਉਣ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਨਿਰਪੱਖ ਹੈ। ਹਦਾਇਤਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦਿਆਂ, ਇਹ ਦਸਤਖਤ ਕੀਤੇ ਅਤੇ ਹਸਤਾਖਰਿਤ ਦੋਵੇਂ ਨੰਬਰਾਂ ਨੂੰ ਦਰਸਾ ਸਕਦਾ ਹੈ। ਜੋੜ ਕਾਰਵਾਈ ਦੀ ਨੁਮਾਇੰਦਗੀ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਸ ਨਾਲ ਕੋਈ ਫ਼ਰਕ ਨਹੀਂ ਪੈਂਦਾ, ਇਸ ਲਈ ਹਸਤਾਖਰਿਤ ਜਾਂ ਹਸਤਾਖਰਿਤ ਸੰਖਿਆਵਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਵਿੱਚ ਕੋਈ ਅੰਤਰ ਨਹੀਂ ਹੈ। ਇੱਥੇ ਮੈਂ ਇਹ ਨੋਟ ਕਰਨਾ ਚਾਹਾਂਗਾ ਕਿ C ਭਾਸ਼ਾ ਵਿੱਚ, ਇੱਕ ਸਾਈਨ ਕੀਤੇ ਪੂਰਨ ਅੰਕ ਵੇਰੀਏਬਲ ਨੂੰ ਓਵਰਫਲੋ ਕਰਨ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਵਿਵਹਾਰ ਹੁੰਦਾ ਹੈ, ਇਸਲਈ ਕਲੈਂਗ ਫਰੰਟਐਂਡ ਓਪਰੇਸ਼ਨ ਵਿੱਚ ਇੱਕ ਫਲੈਗ ਜੋੜਦਾ ਹੈ। 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. ਨਿਰਦੇਸ਼ ਕਾਫ਼ੀ ਅਸਧਾਰਨ ਹਨ ਅਤੇ ਸਮਝਣ ਵਿੱਚ ਕੁਝ ਸਮਾਂ ਲੱਗ ਸਕਦਾ ਹੈ। ਯਾਦ ਰੱਖੋ, ਕਿ SSA ਸਟੈਟਿਕ ਸਿੰਗਲ ਅਸਾਈਨਮੈਂਟ ਲਈ ਛੋਟਾ ਹੈ। ਇਹ ਕੰਪਾਈਲਰਾਂ ਦੁਆਰਾ ਵਰਤੇ ਗਏ ਕੋਡ ਦੀ ਇੱਕ ਵਿਚਕਾਰਲੀ ਨੁਮਾਇੰਦਗੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਹਰੇਕ ਵੇਰੀਏਬਲ ਨੂੰ ਕੇਵਲ ਇੱਕ ਵਾਰ ਇੱਕ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਸਾਡੇ ਫੰਕਸ਼ਨ ਵਰਗੇ ਸਧਾਰਨ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਪ੍ਰਗਟ ਕਰਨ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹੈ myAddਉੱਪਰ ਦਿਖਾਇਆ ਗਿਆ ਹੈ, ਪਰ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਫੰਕਸ਼ਨਾਂ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੈ ਜਿਵੇਂ ਕਿ ਇਸ ਭਾਗ ਵਿੱਚ ਚਰਚਾ ਕੀਤੀ ਗਈ ਫੰਕਸ਼ਨ sum. ਖਾਸ ਤੌਰ 'ਤੇ, ਲੂਪ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੌਰਾਨ ਵੇਰੀਏਬਲ ਬਦਲਦੇ ਹਨ i и n.

SSA ਇੱਕ ਅਖੌਤੀ ਹਦਾਇਤ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਵਾਰ ਵੇਰੀਏਬਲ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਨ 'ਤੇ ਪਾਬੰਦੀ ਨੂੰ ਬਾਈਪਾਸ ਕਰਦਾ ਹੈ phi (ਇਸਦਾ ਨਾਮ ਯੂਨਾਨੀ ਵਰਣਮਾਲਾ ਤੋਂ ਲਿਆ ਗਿਆ ਹੈ)। ਤੱਥ ਇਹ ਹੈ ਕਿ ਸੀ ਵਰਗੀਆਂ ਭਾਸ਼ਾਵਾਂ ਲਈ ਕੋਡ ਦੀ SSA ਪ੍ਰਤੀਨਿਧਤਾ ਲਈ, ਤੁਹਾਨੂੰ ਕੁਝ ਚਾਲ ਦਾ ਸਹਾਰਾ ਲੈਣਾ ਪਵੇਗਾ। ਇਸ ਹਦਾਇਤ ਨੂੰ ਕਾਲ ਕਰਨ ਦਾ ਨਤੀਜਾ ਵੇਰੀਏਬਲ ਦਾ ਮੌਜੂਦਾ ਮੁੱਲ ਹੈ (i ਜ n), ਅਤੇ ਮੂਲ ਬਲਾਕਾਂ ਦੀ ਸੂਚੀ ਇਸਦੇ ਮਾਪਦੰਡਾਂ ਵਜੋਂ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇਸ ਹਦਾਇਤ 'ਤੇ ਗੌਰ ਕਰੋ:

t0 = phi [entry: 0:int, for.body: t6] #n

ਇਸਦਾ ਅਰਥ ਇਸ ਪ੍ਰਕਾਰ ਹੈ: ਜੇਕਰ ਪਿਛਲਾ ਮੂਲ ਬਲਾਕ ਇੱਕ ਬਲਾਕ ਸੀ entry (ਇਨਪੁਟ), ਫਿਰ t0 ਇੱਕ ਸਥਿਰ ਹੈ 0, ਅਤੇ ਜੇਕਰ ਪਿਛਲਾ ਮੂਲ ਬਲਾਕ ਸੀ for.body, ਫਿਰ ਤੁਹਾਨੂੰ ਮੁੱਲ ਲੈਣ ਦੀ ਲੋੜ ਹੈ t6 ਇਸ ਬਲਾਕ ਤੋਂ. ਇਹ ਸਭ ਕੁਝ ਕਾਫ਼ੀ ਰਹੱਸਮਈ ਲੱਗ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਵਿਧੀ ਐਸਐਸਏ ਨੂੰ ਕੰਮ ਕਰਦੀ ਹੈ। ਮਨੁੱਖੀ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਇਹ ਸਭ ਕੋਡ ਨੂੰ ਸਮਝਣਾ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦਾ ਹੈ, ਪਰ ਇਹ ਤੱਥ ਕਿ ਹਰੇਕ ਮੁੱਲ ਨੂੰ ਸਿਰਫ਼ ਇੱਕ ਵਾਰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਬਹੁਤ ਸਾਰੇ ਅਨੁਕੂਲਨ ਨੂੰ ਬਹੁਤ ਸੌਖਾ ਬਣਾਉਂਦਾ ਹੈ।

ਨੋਟ ਕਰੋ ਕਿ ਜੇ ਤੁਸੀਂ ਆਪਣਾ ਕੰਪਾਈਲਰ ਲਿਖਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਇਸ ਕਿਸਮ ਦੀ ਸਮੱਗਰੀ ਨਾਲ ਨਜਿੱਠਣ ਦੀ ਲੋੜ ਨਹੀਂ ਪਵੇਗੀ। ਇੱਥੋਂ ਤੱਕ ਕਿ ਕਲੈਂਗ ਵੀ ਇਹ ਸਾਰੀਆਂ ਹਦਾਇਤਾਂ ਤਿਆਰ ਨਹੀਂ ਕਰਦਾ ਹੈ phi, ਇਹ ਇੱਕ ਵਿਧੀ ਵਰਤਦਾ ਹੈ alloca (ਇਹ ਆਮ ਲੋਕਲ ਵੇਰੀਏਬਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਵਰਗਾ ਹੈ)। ਫਿਰ, ਜਦੋਂ ਇੱਕ LLVM ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਪਾਸ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ mem2reg, ਨਿਰਦੇਸ਼ alloca SSA ਫਾਰਮ ਵਿੱਚ ਬਦਲਿਆ ਗਿਆ। TinyGo, ਹਾਲਾਂਕਿ, Go SSA ਤੋਂ ਇਨਪੁਟ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਸੁਵਿਧਾਜਨਕ ਤੌਰ 'ਤੇ, ਪਹਿਲਾਂ ਹੀ 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) ਇੱਕ ਢਾਂਚੇ (ਢਾਂਚਾ) ਦੇ ਤੌਰ ਤੇ, ਪਰ ਉਹਨਾਂ ਨੂੰ ਤਿੰਨ ਵੱਖਰੀਆਂ ਇਕਾਈਆਂ ਦੇ ਰੂਪ ਵਿੱਚ ਦਰਸਾਉਣਾ ਕੁਝ ਅਨੁਕੂਲਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਹੋਰ ਕੰਪਾਈਲਰ ਟਾਰਗੇਟ ਪਲੇਟਫਾਰਮ ਦੇ ਫੰਕਸ਼ਨਾਂ ਦੇ ਕਾਲਿੰਗ ਕਨਵੈਨਸ਼ਨਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਸਲਾਈਸ ਨੂੰ ਹੋਰ ਤਰੀਕਿਆਂ ਨਾਲ ਪੇਸ਼ ਕਰ ਸਕਦੇ ਹਨ।

ਇਸ ਕੋਡ ਦੀ ਇਕ ਹੋਰ ਦਿਲਚਸਪ ਵਿਸ਼ੇਸ਼ਤਾ ਹਦਾਇਤ ਦੀ ਵਰਤੋਂ ਹੈ 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-ਅਧਾਰਿਤ ਕੰਪਾਈਲਰ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਵੇਲੇ ਅਕਸਰ ਹਵਾਲਾ ਦਿੰਦੇ ਹੋ। ਇਥੇ ਅਗਵਾਈ, ਜੋ ਕਿ ਇੱਕ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਭਾਸ਼ਾ ਲਈ ਇੱਕ ਕੰਪਾਈਲਰ ਵਿਕਸਿਤ ਕਰਨ 'ਤੇ ਨਜ਼ਰ ਮਾਰਦਾ ਹੈ। ਜਾਣਕਾਰੀ ਦੇ ਇਹ ਦੋਵੇਂ ਸਰੋਤ ਤੁਹਾਡੇ ਆਪਣੇ ਕੰਪਾਈਲਰ ਬਣਾਉਣ ਵੇਲੇ ਤੁਹਾਡੇ ਲਈ ਲਾਭਦਾਇਕ ਹੋਣਗੇ।

ਪਿਆਰੇ ਪਾਠਕ! ਕੀ ਤੁਸੀਂ LLVM ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ?

ਸਰੋਤ: www.habr.com