Koncept nedefinovaného chování v jazyku C3

Obsah

1. Koncept nedefinovaného chování v jazyku C3

2. Bezpečné a potenciálně nebezpečné režimy překladu

3. Dělení nulou

4. Dělení se zbytkem (modulo) nulou

5. Změna znaménka nejmenší celočíselné hodnoty (daného typu) se znaménkem

6. Změna znaménka operací součinu nebo podílu

7. Přetečení u celočíselných typů se znaménkem (signed)

8. Nedefinované hodnoty lokálních konstant v různých režimech překladu

9. Přístup k prvku pole s indexem, který přesahuje meze pole

10. Nepatrně složitější příklad přístupu do neexistujícího prvku pole

11. Překročení meze u řezů (slice)

12. Přístup do paměti přes nulový ukazatel

13. Nedodržení specifikovaného kontraktu: podmínka pro vstupní parametry

14. Nedodržení specifikovaného kontraktu: podmínka pro výslednou hodnotu

15. Přístup k lokální proměnné mimo oblast její platnosti (příklad v C)

16. Realizace stejného programu v jazyku C3

17. Bitový posun se specifikací záporného počtu bitů

18. Obsah navazující části

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Koncept nedefinovaného chování v jazyku C3

Většina článků a především videí o programovacích jazycích se primárně zaměřuje na zajímavé vlastnosti zvoleného programovacího jazyka, popř. na rozdíly mezi popisovaným programovacím jazykem a ostatními mainstreamovými jazyky. Ovšem v praxi je nutné, aby vývojáři dobře znali i temná zákoutí specifikace programovacího jazyka. A mezi tato temná zákoutí patří i nedefinované chování (undefined behavior) neboli krátce UB. Jsou to takové programové konstrukce, které mohou být vykonávány různým způsobem v závislosti na zvoleném překladači, parametrech překladu, použité platformě, operačním systému, zvoleném způsobu zarovnání dat v operační paměti atd. atd. Typicky jsou tyto oblasti ve specifikaci jazyka popsány buď vágním způsobem, nebo je (v lepším případě) přímo specifikováno, že se určitá programová konstrukce může chovat v závislosti na implementaci.

Dnes si popíšeme ty programové konstrukce jazyka C3, u kterých je explicitně řečeno, že mají nedefinované chování (a nejedná se tedy o chyby překladače nebo runtime).

2. Bezpečné a potenciálně nebezpečné režimy překladu

Překladač jazyka C3 může při překladu programů používat různé optimalizační metody. Na rozdíl od (například) programovacího jazyka C je v případě C3 jasně specifikováno, které režimy překladu vedou k takzvanému bezpečnému (safe) kódu a které naopak vedou ke kódu, z něhož byly odstraněny některé bezpečnostní konstrukce (unsafe). Překlad v „bezpečném“ režimu vede k pomalejšímu a objemnějšímu binárnímu kódu, do kterého jsou vloženy testy potenciálně nebezpečných stavů – což od vysokoúrovňového jazyka mnohdy očekáváme. A naopak v unsafe režimu získáme kratší a rychlejší výsledek, který ovšem může vykazovat chybné chování, které není hlášeno (bude ignorováno, pokud kontroly nepřidáme přímo do zdrojových kódů):

  -O0         - Safe, no optimizations, emit debug info.
  -O1         - Safe, high optimization, emit debug info.
  -O2         - Unsafe, high optimization, emit debug info.
  -O3         - Unsafe, high optimization, single module, emit debug info.
  -O4         - Unsafe, highest optimization, relaxed maths, single module, emit debug info, no panic messages.
  -O5         - Unsafe, highest optimization, fast maths, single module, emit debug info, no panic messages, no backtrace.
  -Os         - Unsafe, high optimization, small code, single module, no debug info, no panic messages.
  -Oz         - Unsafe, high optimization, tiny code, single module, no debug info, no panic messages, no backtrace.

3. Dělení nulou

Velmi dobrým příkladem nedefinovaného chování je dělení nulou. V případě, že jsou zapnuty optimalizace, přesněji řečeno ty optimalizace, které jsou v tabulce z předchozí kapitoly označeny slovem unsafe, může dělení nulou vrátit jakýkoli výsledek. Naopak v safe režimu vznikne při dělení nulou běhová chyba.

Otestovat si to můžeme velmi snadno:

module undefined_behaviour;
import std::io;
 
fn int div(int a, int b)
{
    return a/b;
}
 
fn void main()
{
    io::printf("%d/%d=%d\n", 2, 1, div(2, 1));
    io::printf("%d/%d=%d\n", 1, 0, div(1, 0));
}

Překlad s využitím safe a následné spuštění:

$ ./c3c compile-run 01_div_by_zero.c3

V tomto režimu vznikne při pokusu o dělení nulou běhová chyba, která není zachycena, takže je aplikace ukončena:

Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
2/1=2
 
ERROR: 'Division by zero.'
  in std.core.builtin.default_panic (/home/ptisnovs/xy/c3c/build/lib/std/core/builtin.c3:175) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in undefined_behaviour.div (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/01_div_by_zero.c3:6) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in undefined_behaviour.main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/01_div_by_zero.c3:12) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in @main_to_void_main (/home/ptisnovs/xy/c3c/build/lib/std/core/private/main_stub.c3:18) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour] [inline]
  in main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/01_div_by_zero.c3:9) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in __libc_start_call_main (source unavailable) [/lib64/libc.so.6]
  in __libc_start_main_alias_2 (source unavailable) [/lib64/libc.so.6]
  in _start (source unavailable) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
Program interrupted by signal 4.

Naopak překlad s využitím unsafe režimu nebude takovou chybu detekovat a výsledek dělení nulou může být jakýkoli:

$ ./c3c compile-run -O3 01_div_by_zero.c3

Zde konkrétně dělení nulou vrátilo nulovou hodnotu, ale opravdu se může jednat o jakékoli číslo – a chování bude stále přesně odpovídat specifikaci jazyka C3:

Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
2/1=2
1/0=0

4. Dělení se zbytkem (modulo) nulou

Naprosto stejným způsobem je jako nedefinované chování označen výsledek výpočtu zbytku po dělení (modulo). Opět si to otestujeme na velmi jednoduchém demonstračním příkladu:

module undefined_behaviour;
import std::io;
 
fn int mod(int a, int b)
{
    return a%b;
}
 
fn void main()
{
    io::printf("%d/%d=%d\n", 2, 1, mod(2, 1));
    io::printf("%d/%d=%d\n", 1, 0, mod(1, 0));
}

Překlad v safe režimu

$ ./c3c compile-run 02_mod_by_zero.c3

Opět dojde k vyhození běhové chyby (ovšem odlišné):

Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
2/1=0
 
ERROR: '% by zero.'
  in std.core.builtin.default_panic (/home/ptisnovs/xy/c3c/build/lib/std/core/builtin.c3:175) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in undefined_behaviour.mod (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/02_mod_by_zero.c3:6) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in undefined_behaviour.main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/02_mod_by_zero.c3:12) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in @main_to_void_main (/home/ptisnovs/xy/c3c/build/lib/std/core/private/main_stub.c3:18) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour] [inline]
  in main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/02_mod_by_zero.c3:9) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in __libc_start_call_main (source unavailable) [/lib64/libc.so.6]
  in __libc_start_main_alias_2 (source unavailable) [/lib64/libc.so.6]
  in _start (source unavailable) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
Program interrupted by signal 4.

Naproti tomu v unsafe režimu je chování explicitně nedefinované a může se vrátit jakákoli hodnota:

$ ./c3c compile-run -O3 02_mod_by_zero.c3
 
Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
2/1=0
1/0=0
Program completed with exit code 0.

5. Změna znaménka nejmenší celočíselné hodnoty (daného typu) se znaménkem

V některých programovacích jazycích není definováno, jaký bude výsledek operace pro změnu znaménka v případě, že vstupem do této operace je nejmenší možné celé číslo pro použitý datový typ. Například datový typ short je ve specifikaci programovacího jazyka C3 uveden zcela přesně – jedná se o šestnáctibitovou hodnoty se znaménkem, tedy o hodnoty v rozsahu –32768 až +32767. Problém změny znaménka spočívá v tom, že rozsah hodnot není symetrický okolo nuly, neboli pokud se pokusíme o změnu znaménka hodnoty –32768, bude výsledek mimo rozsah typu short. V případě jazyka C3 je výsledek (na rozdíl od některých jiných jazyků) přesně specifikován:

module undefined_behaviour;
import std::io;
 
fn short foo(short a)
{
    return -a;
}
 
fn void main()
{
    io::printf("%d->%d\n", 0, foo(0));
    io::printf("%d->%d\n", 1, foo(1));
    io::printf("%d->%d\n", 32767, foo(32767));
    io::printf("%d->%d\n", -32767, foo(-32767));
    io::printf("%d->%d\n", -32768, foo(-32768));
}

Výsledky jsou v tomto případě vždy přesně specifikovány:

0->0
1->-1
32767->-32767
-32767->32767
-32768->-32768

6. Změna znaménka operací součinu nebo podílu

Prakticky stejné (přesně definované) chování programovací jazyk C3 zajišťuje i v případě součinu nebo podílu hodnotou –1. Opět totiž platí, že C3 i u celočíselných datových typů se znaménkem přesně určuje výsledek -1×x, kde x je nejmenší hodnota daného celočíselného datového typu:

module undefined_behaviour;
import std::io;
 
fn short foo(short a)
{
    return -1*a;
}
 
fn void main()
{
    io::printf("%d->%d\n", 0, foo(0));
    io::printf("%d->%d\n", 1, foo(1));
    io::printf("%d->%d\n", 32767, foo(32767));
    io::printf("%d->%d\n", -32767, foo(-32767));
    io::printf("%d->%d\n", -32768, foo(-32768));
}

Výsledky:

0->0
1->-1
32767->-32767
-32767->32767
-32768->-32768

Totéž platí i pro operaci podílu:

module undefined_behaviour;
import std::io;

fn short foo(short a)
{
    return a/-1;
}

fn void main()
{
    io::printf("%d->%d\n", 0, foo(0));
    io::printf("%d->%d\n", 1, foo(1));
    io::printf("%d->%d\n", 32767, foo(32767));
    io::printf("%d->%d\n", -32767, foo(-32767));
    io::printf("%d->%d\n", -32768, foo(-32768));
}

7. Přetečení u celočíselných typů se znaménkem (signed)

Předchozí dva demonstrační příklady ukazovaly (definované) chování programovacího jazyka C3 při provádění operací s hodnotami celočíselného datového typu se znaménkem (signed). Ve skutečnosti jsou v jazyku C3 operace s typy se znaménkem vždy přesně definovány (specifikace říká, že se používá dvojkový doplněk), což je v ostrém kontrastu například s programovacím jazykem C. Například následující demonstrační příklad bude vždy vracet korektní (definované) výsledky, bez ohledu na použitou architekturu či překladač:

module undefined_behaviour;
import std::io;
 
fn short inc(short a)
{
    return a+1;
}
 
fn void main()
{
    io::printf("%d+1=%d\n", 0, inc(0));
    io::printf("%d+1=%d\n", 1, inc(1));
    io::printf("%d+1=%d\n", 32766, inc(32766));
    io::printf("%d+1=%d\n", 32767, inc(32767));
    io::printf("%d+1=%d\n", -32767, inc(-32767));
    io::printf("%d+1=%d\n", -32768, inc(-32768));
}

Výsledky budou stejné na všech architekturách:

0+1=1
1+1=2
32766+1=32767
32767+1=-32768
-32767+1=-32766
-32768+1=-32767

8. Nedefinované hodnoty lokálních konstant v různých režimech překladu

Popišme si další nedefinované chování programovacího jazyka C3. To se týká lokálních proměnných, tj. proměnných, které jsou viditelné v rámci nějakého bloku. Výchozí hodnota těchto proměnných je určena následujícím způsobem:

1. Pokud je provedena explicitní inicializace, má vždy přednost (toto je plně definované chování)
2. Neinicializovaná lokální proměnná je vynulována (i zde se jedná o definované chování)
3. Proměnná označená jako @noinit (nedefinované chování, závisí na způsobu překladu)

Otestujme všechny tři výše uvedené možnosti na následujícím demonstračním příkladu:

module undefined_behaviour;
import std::io;
 
fn void main()
{
    int x = 0;
    int y;
    int z @noinit;
    io::printf("x: %d\n", x);
    io::printf("y: %d\n", y);
    io::printf("z: %d\n", z);
}

Překlad v safe režimu může vést k tomu, že se indikuje chyba popř. bude proměnná vynulována (ovšem nevíme, která možnost nastane):

$ c3c compile-run 05_undefined_value.c3
 
Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
x: 0
y: 0
z: 0

Naproti tomu překlad v unsafe režimu nás o tomto potenciálním problému vůbec neinformuje a proměnná bude mít nedefinovaný obsah.

9. Přístup k prvku pole s indexem, který přesahuje meze pole

Dalším potenciálně problematickým místem je přístup k prvkům polí nebo řezů v případě, že index prvku, který je čten nebo zapisován, leží mimo meze pole či řezu. Některé (jednodušší) chyby tohoto typu dokáže odhalit překladač jazyka C3. Je tomu tak i v následujícím případě:

module undefined_behaviour;
import std::io;
 
fn void main()
{
    int[10] a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
    io::printf("a=%s\n", a);
 
    io::printf("a[0]=%d\n", a[0]);
    io::printf("a[9]=%d\n", a[9]);
    io::printf("a[10]=%d\n", a[10]);
}

Chyba na posledním řádku funkce main je v tomto případě překladačem jazyka C3 odhalena:

$ ./c3c compile-run 06_out_of_bounds_1.c3
 
 9:
10:     io::printf("a[0]=%d\n", a[0]);
11:     io::printf("a[9]=%d\n", a[9]);
12:     io::printf("a[10]=%d\n", a[10]);
                                   ^^
(/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/06_out_of_bounds_1.c3:12:32) Error: An index of '10' is out of range, a value between 0 and 9 was expected.

10. Nepatrně složitější příklad přístupu do neexistujícího prvku pole

V předchozím demonstračním příkladu sice překladač programovacího jazyka C3 korektně odhalil přístup k neexistujícímu prvku pole, ovšem další (podobné) případy již odhalit nedokáže (alespoň nikoli v současné verzi). Například v následujícím zdrojovém kódu modifikujeme v programové smyčce všechny prvky pole, ovšem meze smyčky jsou nastaveny špatně – počítáme s jedním prvkem navíc:

module undefined_behaviour;
import std::io;
 
fn void main()
{
    int[10] a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
    io::printf("a=%s\n", a);
 
    for (int i=0; i<a.len+1; i++) {
        io::printf("a[%d]=%d\n", i, a[i]);
        a[i] = (i + 1)*10;
    }
}

Tato chyba je detekována až po spuštění programu, ovšem pouze v případě, že provedeme překlad v safe režimu:

$ ./c3c compile-run 07_out_of_bounds_2.c3
 
Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
a=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a[0]=1
a[1]=2
a[2]=3
a[3]=4
a[4]=5
a[5]=6
a[6]=7
a[7]=8
a[8]=9
a[9]=10
 
ERROR: 'Array index out of bounds (array had size 10, index was 10)'
  in std.core.builtin.default_panic (/home/ptisnovs/xy/c3c/build/lib/std/core/builtin.c3:175) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in std.core.builtin.panicf (/home/ptisnovs/xy/c3c/build/lib/std/core/builtin.c3:231) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in undefined_behaviour.main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/07_out_of_bounds_2.c3:11) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in @main_to_void_main (/home/ptisnovs/xy/c3c/build/lib/std/core/private/main_stub.c3:18) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour] [inline]
  in main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/07_out_of_bounds_2.c3:4) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in __libc_start_call_main (source unavailable) [/lib64/libc.so.6]
  in __libc_start_main_alias_2 (source unavailable) [/lib64/libc.so.6]
  in _start (source unavailable) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
Program interrupted by signal 4.

Po překladu v režimu unsafe přistupujeme k neexistujícímu prvku a tedy do paměti, která nám nepatří:

$ ./c3c compile-run -O5 07_out_of_bounds_2.c3
 
Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
a=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a[0]=1
a[1]=2
a[2]=3
a[3]=4
a[4]=5
a[5]=6
a[6]=7
a[7]=8
a[8]=9
a[9]=10
a[10]=0
Program completed with exit code 0.

11. Překročení meze u řezů (slice)

Podobně může program reagovat (v runtime, tedy za běhu) i při přístupu do pole přes řez (slice). Pokusme se tedy program z předchozí kapitoly upravit takovým způsobem, aby se namísto pole použil řez:

module undefined_behaviour;
import std::io;
 
fn void main()
{
    io::printf("type: %s\n", int[].nameof);
 
    int[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
    io::printf("a=%s\n", a);
 
    for (int i=0; i<a.len+1; i++) {
        a[i] = (i + 1)*10;
    }
    io::printf("a=%s\n", a);
}

Pokud je překlad proveden v safe režimu, program po svém spuštění detekuje přístup mimo meze řezu a bude nás o tom patřičně informovat:

$ c3c compile-run 11_out_of_bounds_slice.c3
 
Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
type: int[]
a=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
ERROR: 'Array index out of bounds (array had size 10, index was 10)'
  in std.core.builtin.default_panic (/home/ptisnovs/xy/c3c/build/lib/std/core/builtin.c3:175) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in std.core.builtin.panicf (/home/ptisnovs/xy/c3c/build/lib/std/core/builtin.c3:231) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in undefined_behaviour.main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/11_out_of_bounds_slice.c3:13) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in @main_to_void_main (/home/ptisnovs/xy/c3c/build/lib/std/core/private/main_stub.c3:18) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour] [inline]
  in main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/11_out_of_bounds_slice.c3:4) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in __libc_start_call_main (source unavailable) [/lib64/libc.so.6]
  in __libc_start_main_alias_2 (source unavailable) [/lib64/libc.so.6]
  in _start (source unavailable) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
Program interrupted by signal 4.

V unsafe režimu však kontroly ve výsledném spustitelném souboru chybí a opět tedy přistupujeme k paměti, která nám nepatří (a stát se může obecně cokoli):

$ ./c3c compile-run -O5 11_out_of_bounds_slice.c3
 
Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
type: int[]
a=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a=[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Program completed with exit code 0.

12. Přístup do paměti přes nulový ukazatel

Na další nedefinované chování narazíme ve chvíli, kdy běžící program přistupuje k paměti přes nulový (null) ukazatel. Podívejme se na ten nejjednodušší případ takového chování (který kupodivu není odhalen překladačem). Pokoušíme se vypsat hodnotu z paměti, ovšem namísto korektní adresy se předává nulový ukazatel:

module undefined_behaviour;
import std::io;
 
fn void main()
{
    int *p = null;
 
    io::printf("%d\n", *p);
}

Pokud je program přeložen v safe režimu, bude chyba odhalena, ale až v runtime:

$ c3c compile-run 08_null_pointer.c3
 
Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
 
ERROR: 'Dereference of null pointer, '(int*)arg' was null.'
  in std.core.builtin.default_panic (/home/ptisnovs/xy/c3c/build/lib/std/core/builtin.c3:175) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in std.io.int_from_any (/home/ptisnovs/xy/c3c/build/lib/std/io/formatter_private.c3:64) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in @wrap_bad (/home/ptisnovs/xy/c3c/build/lib/std/io/formatter.c3:558) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour] [inline]
  in std.io.Formatter.vprintf (/home/ptisnovs/xy/c3c/build/lib/std/io/formatter.c3:558) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in std.io.printf (/home/ptisnovs/xy/c3c/build/lib/std/io/io.c3:299) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in undefined_behaviour.main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/08_null_pointer.c3:8) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in @main_to_void_main (/home/ptisnovs/xy/c3c/build/lib/std/core/private/main_stub.c3:18) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour] [inline]
  in main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/08_null_pointer.c3:4) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in __libc_start_call_main (source unavailable) [/lib64/libc.so.6]
  in __libc_start_main_alias_2 (source unavailable) [/lib64/libc.so.6]
  in _start (source unavailable) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
Program interrupted by signal 4.

Naopak v unsafe režimu runtime systém jazyka C3 problém neodhalí a program může zhavarovat až při realizaci přístupu na nulovou adresu (což není v chráněném režimu povoleno):

$ ./c3c compile-run -O5 08_null_pointer.c3 
 
Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
Program interrupted by signal 11.

13. Nedodržení specifikovaného kontraktu: podmínka pro vstupní parametry

Připomeňme si, že v jazyku C3 je možné u funkcí a metod specifikovat takzvané kontrakty, což jsou podmínky, které musí platit pro vstupní parametry funkce (platné a inicializované v době jejího volání) popř. naopak podmínky, které musí platit pro výslednou hodnotu. Podpora kontraktů je mimochodem jedním z nejužitečnějších rysů tohoto programovacího jazyka. Ovšem kontrakty mají též obecně nedefinované chování. Jsou totiž vyhodnocovány pouze při použití safe režimu překladu.

Otestujme si to na kontraktu definovaném pro hodnotu vstupního parametru. Pokusíme se zabránit dělení nulou:

module undefined_behaviour;
import std::io;
 
<*
 @require b != 0
*>
fn int div(int a, int b)
{
    return a/b;
}
 
fn void main()
{
    io::printf("%d/%d=%d\n", 2, 1, div(2, 1));
    io::printf("%d/%d=%d\n", 1, 0, div(1, 0));
}

Tento kontrakt, resp. jeho porušení může být detekováno, ovšem není zaručeno, že to bude platit i pro unsafe režimy překladu:

$ c3c compile-run 09_contract.c3
 
12: fn void main()
13: {
14:     io::printf("%d/%d=%d\n", 2, 1, div(2, 1));
15:     io::printf("%d/%d=%d\n", 1, 0, div(1, 0));
                                       ^^^^^^^^^
(/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/09_contract.c3:15:36) Error: @require "b != 0" violated.

Naopak překlad v unsafe režimu povede k tomu, že se bude dělit nulou, což je vlastně druhé nedefinované chování způsobené prvním nedefinovaným chováním:

$ c3c compile-run -O5 09_contract.c3
 
Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
2/1=2
1/0=0
Program completed with exit code 0.

14. Nedodržení specifikovaného kontraktu: podmínka pro výslednou hodnotu

Prakticky totéž platí i pro kontrakt, kterým je určena podmínka či podmínky, které musí platit pro výslednou (návratovou) hodnotu funkce. Opět si to otestujme:

module undefined_behaviour;
import std::io;
 
<*
 @ensure return > a
*>
fn short add(short a, short b)
{
    return a+b;
}
 
fn void main()
{
    io::printf("%d+%d=%d\n", 1, 1, add(1, 1));
    io::printf("%d+%d=%d\n", 32767, 1, add(32767, 1));
}

Chování tohoto programu se bude opět odlišovat v závislosti na tom, jaký režim překladu je použit.

Použití safe režimu překladu:

$ ./c3c compile-run 10_contract.c3
 
Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
1+1=2
 
ERROR: '@ensure "return > a" violated.'
  in std.core.builtin.default_panic (/home/ptisnovs/xy/c3c/build/lib/std/core/builtin.c3:175) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in undefined_behaviour.add (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/10_contract.c3:9) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in undefined_behaviour.main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/10_contract.c3:15) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in @main_to_void_main (/home/ptisnovs/xy/c3c/build/lib/std/core/private/main_stub.c3:18) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour] [inline]
  in main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/10_contract.c3:12) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in __libc_start_call_main (source unavailable) [/lib64/libc.so.6]
  in __libc_start_main_alias_2 (source unavailable) [/lib64/libc.so.6]
  in _start (source unavailable) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]

Použití unsafe režimu překladu:

$ ./c3c compile-run -O5 10_contract.c3
 
Program linked to executable './undefined_behaviour'.
Launching ./undefined_behaviour
1+1=2
Program interrupted by signal 11.

15. Přístup k lokální proměnné mimo oblast její platnosti (příklad v C)

V této kapitole na chvíli odbočme od jazyka C3 zpátky k jeho ideovému předchůdci, tedy ke slavnému céčku. Podívejme se na následující příklad, ve kterém se z funkce foo vrací ukazatel na lokální proměnnou. Problém spočívá v tom, že mimo čas, kdy se provádí příkazy ve funkci foo, nejsou lokální (nestatické) proměnné alokovány, takže nemá smysl vracet odkaz na ně (a už vůbec ne přistupovat přes tento odkaz do paměti):

#include <stdio.h>
 
int* foo()
{
    int a = 42;
    return &a;
}
 
int main(void)
{
    int *p = foo();
    printf("%d\n", *p);
    *p = -1;
    return 0;
}

Běžný překlad pomocí GCC i jiných překladačů bude proveden, „pouze“ se vypíše varování:

$ gcc -Wall -pedantic 12_local_variable_pointer.c
 
12_local_variable_pointer.c: In function ‘foo’:
12_local_variable_pointer.c:6:12: warning: function returns address of local variable [-Wreturn-local-addr]
    6 |     return &a;
      |            ^~

popř.:

$ clang 12_local_variable_pointer.c
 
12_local_variable_pointer.c:6:13: warning: address of stack memory associated with local variable 'a' returned [-Wreturn-stack-address]
    6 |     return &a;
      |             ^
1 warning generated.

Chyba (resp. přímo pád) nastane v runtime:

$ ./a.out
Segmentation fault (core dumped)

Aby byla chyba ohlášena jako skutečná chyba, musíme překladači předat přepínač -Werror:

$ gcc -Wall -Werror -pedantic 12_local_variable_pointer.c
 
12_local_variable_pointer.c: In function ‘foo’:
12_local_variable_pointer.c:6:12: error: function returns address of local variable [-Werror=return-local-addr]
    6 |     return &a;
      |            ^~
cc1: all warnings being treated as errors

popř.:

$ clang -Werror 12_local_variable_pointer.c
 
12_local_variable_pointer.c:6:13: error: address of stack memory associated with local variable 'a' returned [-Werror,-Wreturn-stack-address]
    6 |     return &a;
      |             ^
1 error generated.

16. Realizace stejného programu v jazyku C3

Pokud naprosto stejný program přepíšeme do jazyka C3, bude přístup k lokální proměnné vně funkce korektně detekován překladačem, což je ostatně jen dobře:

module undefined_behaviour;
import std::io;
 
fn int* foo()
{
    int a = 42;
    return &a;
}
 
fn void main()
{
    int *p = foo();
    io::printf("%d\n", *p);
}

Chyba nahlášená při pokusu o překlad (nezávisle na použité úrovni optimalizace):

$ ./c3c compile-run 12_local_variable_pointer.c3
 
 4: fn int* foo()
 5: {
 6:     int a = 42;
 7:     return &a;
               ^^
(/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/12_local_variable_pointer.c3:7:12) Error: A pointer to a local variable will be invalid once the function returns. Allocate the data on the heap or temp memory to return a pointer.

17. Bitový posun se specifikací záporného počtu bitů

Dalším typicky nedefinovaným chováním je v jazyku C3 (ale i v C) bitový posun o záporný počet bitů (to může být poněkud překvapující, ale posledních minimálně čtyřicet let tomu tak skutečně je):

module undefined_behaviour;
import std::io;
 
fn short shift(short a, short b)
{
    return a<<b;
}
 
fn void main()
{
    io::printf("%d+1=%d\n", 0, shift(0, -1));
    io::printf("%d+1=%d\n", 1, shift(1, -1));
    io::printf("%d+1=%d\n", 2, shift(2, -1));
    io::printf("%d+1=%d\n", 32766, shift(32766, -1));
    io::printf("%d+1=%d\n", 32767, shift(32767, -1));
    io::printf("%d+1=%d\n", -32767, shift(-32767, -1));
    io::printf("%d+1=%d\n", -32768, shift(-32768, -1));
}

Chování se opět může odlišovat podle toho, zda je překlad proveden v safe nebo unsafe režimu.

Použití safe režimu:

ERROR: 'Shift amount out of range (was 65535).'
  in std.core.builtin.default_panic (/home/ptisnovs/xy/c3c/build/lib/std/core/builtin.c3:175) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in std.core.builtin.panicf (/home/ptisnovs/xy/c3c/build/lib/std/core/builtin.c3:231) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in undefined_behaviour.shift (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/15_negative_shift.c3:6) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in undefined_behaviour.main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/15_negative_shift.c3:11) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in @main_to_void_main (/home/ptisnovs/xy/c3c/build/lib/std/core/private/main_stub.c3:18) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour] [inline]
  in main (/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/15_negative_shift.c3:9) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
  in __libc_start_call_main (source unavailable) [/lib64/libc.so.6]
  in __libc_start_main_alias_2 (source unavailable) [/lib64/libc.so.6]
  in _start (source unavailable) [/home/ptisnovs/src/c3-examples/c3-undefined-behaviour/undefined_behaviour]
Program interrupted by signal 4.

Použití unsafe režimu (může nastat cokoli):

0+1=0
1+1=0
2+1=0
32766+1=0
32767+1=0
-32767+1=0
-32768+1=0

18. Obsah navazující části

Ve skutečnosti je v jazyku C3 nedefinovaných chování větší množství. Zbylé z nich si popíšeme v navazujícím článku.

19. Repositář s demonstračními příklady

Demonstrační příklady vytvořené pro nejnovější verzi programovacího jazyka C3 byly uloženy do repositáře dostupného na adrese https://github.com/tisnik/c3-examples. Následují odkazy na jednotlivé příklady (či jejich nedokončené části).

Demonstrační příklady z prvního článku o programovacím jazyku C3:

Demonstrační příklady ze druhého článku o jazyku C3:

Demonstrační příklady použité ve třetím článku o jazyku C3:

Demonstrační příklady ze čtvrtého o jazyku C3:

Demonstrační příklady z pátého článku o jazyku C3:

Následují odkazy na demonstrační příklady z článku předchozího:

Demonstrační příklady z předchozího článku o funkcích v C3:

Příklady z předchozího článku s popisem makrosystému jazyka C3:

Demonstrační příklady uvedené v dnešním článku:

20. Odkazy na Internetu

1. Programovací jazyk C3: evoluce, nikoli revoluce
   https://www.root.cz/clanky/pro­gramovaci-jazyk-c3-evoluce-nikoli-revoluce/
2. Programovací jazyk C3: datové typy pro moderní architektury
   https://www.root.cz/clanky/pro­gramovaci-jazyk-c3-datove-typy-pro-moderni-architektury/
3. Programovací jazyk C3: složené datové typy a kontejnery
   https://www.root.cz/clanky/pro­gramovaci-jazyk-c3-slozene-datove-typy-a-kontejnery/
4. The C3 Programming Language
   https://c3-lang.org/
5. C3 For C Programmers
   https://c3-lang.org/language-overview/primer/
6. C3 is a C-like language trying to be an incremental improvement over C rather than a whole new language
   https://www.reddit.com/r/Pro­grammingLanguages/comments/o­ohij6/c3_is_a_clike_langu­age_trying_to_be_an/
7. Tiobe index
   https://www.tiobe.com/tiobe-index/
8. PYPL PopularitY of Programming Language
   https://pypl.github.io/PYPL.html
9. C3 Tutorial
   https://learn-c3.org/
10. History of programming languages
    https://devskiller.com/history-of-programming-languages/
11. History of programming languages (Wikipedia)
    https://en.wikipedia.org/wi­ki/History_of_programming_lan­guages
12. D language
    https://dlang.org/
13. Zig programming language
    https://ziglang.org/
14. V language
    https://vlang.io/
15. D programming language
    https://en.wikipedia.org/wi­ki/D_(programming_language)
16. Zig programming language (Wikipedia)
    https://en.wikipedia.org/wi­ki/Zig_(programming_langu­age)
17. V programming language (Wikipedia)
    https://en.wikipedia.org/wi­ki/V_(programming_language)
18. Syntax highlighting for C3's programming language
    https://github.com/Airbus5717/c3.vim
19. Go factorial
    https://gist.github.com/e­simov/9622710
20. Generational list of programming languages
    https://en.wikipedia.org/wi­ki/Generational_list_of_pro­gramming_languages
21. The Language Tree: Almost Every Programming Language Ever Made
    https://github.com/Phileo­sopher/langmap
22. List of C-family programming languages
    https://en.wikipedia.org/wi­ki/List_of_C-family_programming_languages
23. Compatibility of C and C++
    https://en.wikipedia.org/wi­ki/Compatibility_of_C_and_C%2B%2B
24. C++23: compatibility with C
    https://www.sandordargo.com/blog/2023/08/23/cpp­23-c-compatibility
25. Can C++ Run C Code? Understanding Language Compatibility
    https://www.codewithc.com/can-c-run-c-code-understanding-language-compatibility/
26. C3: Comparisons With Other Languages
    https://c3-lang.org/faq/compare-languages/
27. C3 Programming Language Gains Traction as Modern C Alternative
    https://biggo.com/news/202504040125_C3_Pro­gramming_Language_Alterna­tive_to_C
28. The case against a C alternative
    https://c3.handmade.networ­k/blog/p/8486-the_case_against_a_c_alternative
29. C (programming language) Alternatives
    https://alternativeto.net/software/c-programming-language-/
30. Seriál Programovací jazyk Go
    https://www.root.cz/seria­ly/programovaci-jazyk-go/
31. Is C3 the Underdog That Will Overtake Zig and Odin?
    https://bitshifters.cc/2025/05/22/c3-c-tradition.html
32. „Hello, World!“ program
    https://en.wikipedia.org/wi­ki/%22Hello%2C_World!%22_pro­gram
33. The C Programming Language
    https://en.wikipedia.org/wi­ki/The_C_Programming_Langu­age
34. Kontejner (abstraktní datový typ)
    https://cs.wikipedia.org/wi­ki/Kontejner_(abstraktn%C3%AD_da­tov%C3%BD_typ)
35. Are arrays not considered containers because they are not based off of a class?
    https://stackoverflow.com/qu­estions/37710975/are-arrays-not-considered-containers-because-they-are-not-based-off-of-a-class
36. Array declaration (C, C++)
    https://en.cppreference.com/w/cpp/lan­guage/array.html
37. Understanding the Apple ‘goto fail;’ vulnerability
    https://www.blackduck.com/blog/un­derstanding-apple-goto-fail-vulnerability-2.html
38. Branch (computer science)
    https://en.wikipedia.org/wi­ki/Branch_(computer_scien­ce)
39. Conditional (computer programming)
    https://en.wikipedia.org/wi­ki/Conditional_(computer_pro­gramming)
40. Dangling else
    https://en.wikipedia.org/wi­ki/Dangling_else
41. Switch statement
    https://en.wikipedia.org/wi­ki/Switch_statement
42. Compiler correctness
    https://en.wikipedia.org/wi­ki/Compiler_correctness
43. Anonymous function
    https://en.wikipedia.org/wi­ki/Anonymous_function
44. Closure (computer programming)
    https://en.wikipedia.org/wi­ki/Closure_(computer_program­ming)
45. How to implement closures in C
    https://hokstad.com/how-to-implement-closures
46. An Overview of Macros in Rust
    http://words.steveklabnik.com/an-overview-of-macros-in-rust
47. A Practical Intro to Macros in Rust 1.0
    https://danielkeep.github.io/practical-intro-to-macros.html
48. The Rust Programming Language: macros
    https://doc.rust-lang.org/beta/book/macros.html
49. Rust by example: 15 macro_rules!
    http://rustbyexample.com/macros.html
50. Undefined behavior
    https://en.wikipedia.org/wi­ki/Undefined_behavior
51. Undefined Behavior in C and C++
    https://www.geeksforgeeks­.org/cpp/undefined-behavior-c-cpp/
52. The Rust reference: Behavior considered undefined
    https://doc.rust-lang.org/reference/behavior-considered-undefined.html#behavior-considered-undefined
53. Why would a language have a concept of undefined behavior instead of raising an error?
    https://langdev.stackexchan­ge.com/questions/481/why-would-a-language-have-a-concept-of-undefined-behavior-instead-of-raising-an
54. Undefined behavior
    https://riptutorial.com/c/to­pic/364/undefined-behavior
55. C3: Undefined Behaviour
    https://c3-lang.org/language-rules/undefined-behaviour/
56. Undefined behavior in C and C++
    https://russellw.github.io/undefined-behavior