Renamed undefined c

1 files changed, 0 insertions, 1749 deletions

diff --git a/md/notes/undefined_c/titles.md b/md/notes/undefined_c/titles.md
deleted file mode 100644
index 731d42c..0000000
--- a/md/notes/undefined_c/titles.md
+++ /dev/null
@@ -1,1749 +0,0 @@
-title:Undefined C 
-keywords:c,linux,asm 
-
-# Undefined C
-
-There is possible to run piece of code inside online c compiler like https://www.onlinegdb.com/online_c_compiler
-Or run locally. With base check is done with gcc compiler. There are many small tricks around running C code
-in practice that aren't covered in any generic tutorials, so here is list of topics that may arise while
-coding real C code outside of tutorials. For each case there is just small example, each of those could
-take whole chapter on its own. 
-
-## Compile
-
-
-__hello_world.c__
-```c
-int main() {
-	printf("Hello world\n");
-}
-```
-
-```bash
-gcc hello_world.c -o hello_world
-gcc -m32 hello_world.c -o hello_world_32 #for 32bit target
-```
-
-## Syntax
-
-### Variables
-
-Standard list of available types
-
-#### Check type size
-
-All types have size that are declared in bytes. Some of the types are machine dependents.
-like int/long, if there is needed machine independent types then there are int32_t/uint32_t/int64_t/uint64_t
-
-Each architecture 8bit/16bit/32bit/64bit will have different size for those types
-
-Use __sizeof()__
-
-Running on x86 machine
-```c
-#include <stdint.h>
-#include <stdlib.h>
-#include <stdio.h>
-int main() {
-    printf("Sizeof int %lu\n",sizeof(int));
-    printf("Sizeof int32_t %lu\n",sizeof(int32_t));
-    printf("Sizeof int64_t %lu\n",sizeof(int64_t));
-    printf("Sizeof long %lu\n",sizeof(long));
-    printf("Sizeof long long %lu\n",sizeof(long long));
-}
-```
-
-Most safest/portable way is to use [u]int[8/16/32/64]_t types. 
-
-Defined macros'es to get type max and min values are
-
-https://en.cppreference.com/w/c/types/limits
-
-```c
-#include <limits.h>
-int main() {
-    printf("INT_MIN %d\n",INT_MIN);
-    printf("INT_MAX %d\n", INT_MAX);
-    printf("LONG_MIN %ld\n",LONG_MIN);
-}
-```
-
-Example from AVR __stdint.h__   
-https://github.com/avrdudes/avr-libc/blob/main/include/stdint.h  
-Example from Libc  
-https://sourceware.org/git/?p=glibc.git;a=blob;f=stdlib/stdint.h  
-
-
-
-#### How to shoot the leg
-
-When code suppose to run on 32bit and 64bit platform the size of type may vary.
-Need to take in account this case.
-
-
-
-
-
-### Functions
-
-Function syntax, there is nothing interesting on functions
-
-```
-<RETURN_TYPE> <NAME>(<TYPE> <NAME>,..) {
-    <EXPR>
-}
-```
-
-Write simple function
-
-```c
-int fun1() {
-    return -1;
-}
-```
-
-Function can have multiple return statements.
-Here is example whne function have 3 return values.
-```c
-int fun2(int i) {
-    if (i<0) return -1;
-    if (i>0) return 1;
-    return 0;
-}
-```
-
-Get address of function 
-
-```c
-printf("fun1 address %016x",&fun1);//64bit platform
-```
-
-### If statement
-
-```c
-if () ;
-if () {}
-```
-
-One of the way to check error of returned functions is 
-
-```c
-if ((c = getfun()) == 0) {
-}
-```
-
-Most simplest and outdated way to do this is when getting input from command line
-```c
-#include <stdio.h>
-int main() {
-    int c;
-    char ch;
-    while ((c = getchar()) != EOF ) {
-        ch = c;
-        printf("Typed character %c\n",c);
-    }
-}
-```
-
-### For cycle
-
-For loop is one that may involve some trickery, its 
-as simple as 
-
-```c
-for (<INITIAL>;<TERMINATE CONDITION>;<AFTER CYCLE>) {
-}
-```
-
-Go over values from 1 till 10
-
-```c
-int i=0;
-for (i=1;i<=10;i++) {
-    printf("%d\n",i)
-}
-```
-
-Now lets do it from 10 till 1
-
-```c
-int i=0;
-for (i=10;i>0;i--) {
-    printf("%d\n",i)
-}
-```
-
-Now lets make one liner
-
-```c
-for (i=0;i<10;i++,printf("%d\n",i));
-```
-
-Yes there is possible to write as many expressions as needed.
-
-
-### Structure
-
-Structure allows to combine types under one new type. Structure is convenient way how to combine set 
-of types and reuse them as one. 
-
-```c
-struct struct1 {
-    uint8_t a;
-    uint16_t b;
-    uint32_t c;
-    uint64_t d;
-};
-```
-
-Total intuitive size of structure would be 
-```c
-int total_szie = sizeof(uint8_t) + sizeof(uint16_t) + sizeof(uint32_t) + sizeof(uint64_t);
-int real_size = sizeof(struct1);
-```
-
-Types are placed inside structure to make fast access to them. Some instructions of CPU may require
-to access aligned memory addresses to not have penalty on accessing types inside structure.
-
-To directly mess with alignment of types use attribute
-```c
-__attribute__ ((aligned (8)))
-```
-
-
-Use attributes to pack structure and be not architecture dependent.
-
-```c
-struct struct2 {
-    uint8_t a;
-    uint16_t b;
-    uint32_t c;
-    uint64_t d;
-} __attribute__((packed));
-```
-
-Now let check size of structure after it packed
-
-```c
-int new_size = sizeof(struct2);
-```
-
-Also there is possible to add aligmnet to each time in structure
-```c
-struct struct3 {
-    uint8_t a __attribute__((aligned (8)));
-    uint16_t b __attribute__((aligned (8)));
-    uint32_t c __attribute__((aligned (8)));
-    uint64_t d __attribute__((aligned (8)));
-} __attribute__((aligned (8)));
-```
-
-Now size of structure will be 32. 
-
-All results on amd64, other arch may differ.
-
-### How to shoot leg
-Forget that struct size is not consistent. 
-
-### Recursion
-
-Recursion is technique that could be useful to write shorter code 
-and deal with cycles. One thing that recursion suffer is that it consumes
-stack memory and its have default limit on platform.
-
-```c
-#include <stdio.h>
-#include <stdlib.h>
-
-int fun_r(int i) {
-	printf("val %d\n",i);
-	fun_r(i+1);
-	return 0;
-}
-
-int main() 
-{
-	fun_r(0);
-}
-```
-
-Program will fail after its reach out of stack range.
-When increase the default stack limit it go more further.
-
-
-Check default stack size
-
-```
-ulimit -s
-```
-
-Set stack size
-
-```
-ulimit -s 16384
-```
-
-### Macro
-
-There is many things useful as macros. There is many tricks in macros to emit
-useful parts of code. 
-
-Define values, as its enum. 
-```c
-#define VAL_0 0
-#define VAL_1 1
-#define VAL_LAST VAL_1
-```
-
-Multiline macro
-```c
-#define INC_FUN(TYPE) TYPE inc_##TYPE(a TYPE){\
-    TYPE c=1\
-    return a + c\
-}
-
-INC_FUN(int)
-INC_FUN(char)
-INC_FUN(double)
-INC_FUN(notype)
-```
-
-to check code expansion of macro run
-
-```
-gcc -E <SOURCE_FILE>
-```
-
-
-
-http://main.lv/writeup/c_macro_tricks.md
-
-
-https://jadlevesque.github.io/PPMP-Iceberg/
-
-
-### Pointers
-
-One the C most loved feature is pointers, they allow to access addresses without any sanity check
-and they dont have any lifetime, so anything is possible with those.
-
-Pointer contains address which is interpreted according of pointer type
-
-```c
-int c;
-int ptr=&c;
-```
-
-Go over array of chars
-```c
-#include <stdio.h>
-#include <stdlib.h>
-
-int main() {
-	char s[]="asd";
-	char *c=&s;
-	while (*c != 0) {
-	    printf("NExt char %c addr %016x\n",*c,c);
-	    c++;
-	}
-}
-```
-Go over array of ints
-```c
-    int i=0;
-    int arr[] = {9,7,5,3,1};
-	int *ptr = arr;
-	while (i<5) {
-	    printf("Number value %d addr %016x\n",*ptr, ptr);
-	    ptr++;
-	    i++;
-	} 
-```
-
-Pointer arithmetics like +1 will move to next address that is offset of type size.
-As example below structure size is 12, and increment of pointer to that structure
-increment address to sizeof structure. And yes address is pointing to not mapped memory, so it 
-will segfault if accessed. 
-
-```c
-struct size12 {
-    int a,b,c;
-}
-
-int main() {
-    struct size12 *s=0;
-    s++;
-    printf("%016x\n",s);
-    s++;
-    printf("%016x\n",s);
-}
-```
-
-Double pointers are pointers to pointers
-
-```c
-#include <stdio.h>
-
-int main(int argc, char **argv) {
-	char *arg = argv[0];
-    printf("Program name %s\n",arg);
-}
-```
-
-#### How to shoot the leg
-Run pointer in while loop incrementing pointer. It will stop only when segfaults.
-
-Dont initialize pointer and it will have random value.
-
-
-
-### Allocate memory
-
-From programs perspective memory allocation is adding address range to executable that can be addressed.
-
-malloc should be accompanied with free statement, otherwise it will have memory leaks.
-
-```c
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-int main() {
-    char *c = malloc(16);
-    memset(c,0,16);
-    int *arr = malloc(16*sizeof(int));
-    memset(arr,0,16*sizeof(int));
-    free(c);
-    free(arr);
-}
-```
-
-### Signed/Unsigned
-
-Signed and unsigned variables differ just in one bit interpretation. But they have different behavior on minimal and maximal values.
-
-
-```c
-#include <stdio.h>
-#include <limits.h>
-int main() 
-{
-    int i=INT_MAX;
-    unsigned int u=UINT_MAX;
-
-    printf("i=%d\n",i);
-    printf("u=%u\n",u);
-    
-    i++;
-    u++;
-    printf("i=%d\n",i);
-    printf("u=%u\n",u);
-    i=0;
-    u=0;
-    i--;
-    u--;
-    printf("i=%d\n",i);
-    printf("u=%u\n",u);
-
-}
-```
-
-### Endianess 
-
-
-```c
-#include <stdlib.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <stdint.h>
-
-int main() {
-	int arr[4] = {0x00112233,0x44556677,0x8899AABB, 0xCCDDEEFF};
-	printf("%08x\n",arr[0]);
-	printf("%08x\n",arr[1]);
-	printf("%08x\n",arr[2]);
-	printf("%08x\n",arr[3]);
-
-	FILE *f = fopen("int.hex","w+");
-	fprintf(f,"%08x",arr[0]);
-	fprintf(f,"%08x",arr[1]);
-	fprintf(f,"%08x",arr[2]);
-	fprintf(f,"%08x",arr[3]);
-	fclose(f);
-
-	int fd=open("int.bin",O_CREAT|O_RDWR,S_IWUSR|S_IRUSR|S_IRGRP|S_IRWXO);
-	write(fd,arr,sizeof(arr));
-	close(fd);
-
-	int i;
-    fd = open("int.bin2",O_CREAT|O_RDWR,S_IWUSR|S_IRUSR|S_IRGRP|S_IRWXO);
-    for (i=0;i<4;i++) {
-    	uint32_t val = (arr[i]>>16) &0x0000ffff;
-    	val += (arr[i]<<16)&0xffff0000;
-    	write(fd,&val,sizeof(uint32_t));
-    }
-    close(fd);
-}
-```
-
-While saving formated values to file you will get what you expect
-```
-$ cat int.hex 
-00112233445566778899aabbccddeeff
-```
-
-Saving just memory dump of all values, will give you different result
-```
-$ hexdump int.bin 
-0000000 2233 0011 6677 4455 aabb 8899 eeff ccdd
-0000010
-```
-
-Need to swap 16bit pairs to look same as value memory dump
-```
-$ hexdump int.bin2
-0000000 0011 2233 4455 6677 8899 aabb ccdd eeff
-0000010
-``` 
-
-### Compiler flags
-
-Compiler have whole list of command line arguments that you can enable for different purposes, lets look into some of them
-https://gcc.gnu.org/onlinedocs/gcc/Option-Summary.html
-
-Lets try to apply some of the flags to examples above.
-
-Best starte options is, those will give you more warnings.
-
-```
--Wall -Wextra
-```
-
-Most of the examples here was written in sloppy style, so adding extra checks like will find more issues with code, probably
-all of provided examples will show issues with this extra compiler flags
-
-```
-Wformat-security -Wduplicated-cond -Wfloat-equal -Wshadow -Wconversion -Wjump-misses-init -Wlogical-not-parentheses -Wnull-dereference
-```
-
-To get all macroses expanded in C code add compiler flag. Output will be C source with all macro expansion
-```
--E
-```
-
-Output resulting file not to binary but to generated assembly add
-```
--S
-```
-
-More readable output can be obtained with
-
-```
-gcc FILE.c -Wa,-adhln=FILE.S -g -fverbose-asm -masm=intel
-```
-
-Basic compiler optimisation flags that can speedup program or make it smaller
-
-```
--O  -O0  -O1  -O2  -O3  -Os  -Ofast  -Og  -Oz
-```
-
-https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html#Optimize-Options
-
-https://panthema.net/2013/0124-GCC-Output-Assembler-Code/  
-https://blogs.oracle.com/linux/post/making-code-more-secure-with-gcc-part-1  
-
-
-### Shared library
-
-Shared library is common way how to reuse big chunks of code.
-
-```c
-#include <stdio.h>
-int fun1() {
-	return 1;
-}
-
-int fun2() {
-	printf("Function name fun2\n");
-}
-
-int fun3(int a, int b) {
-	return a+b;
-}
-```
-
-```
-$ gcc -c lib_share.c
-$ gcc -shared -o lib_share.so libshare.o
-$ ldd lib_share.so
-	linux-vdso.so.1 (0x00007ffdb994d000)
-	libc.so.6 => /usr/lib/libc.so.6 (0x00007f0c39400000)
-	/usr/lib64/ld-linux-x86-64.so.2 (0x00007f0c39835000)
-```
-
-Now lets link to our binary
-```c
-#include <stdio.h>
-
-//functions that are implemented in shared lib
-int fun1();
-int fun2();
-int fun3(int a, int b);
-
-int main() {
-	fun1();
-	fun2();
-	fun3();
-}
-```
-
-```
-$ gcc -L. -lshare use_share.c -o use_share
-./use_share 
-./use_share: error while loading shared libraries: libshare.so: cannot open shared object file: No such file or directory
-ldd ./use_share
-	linux-vdso.so.1 (0x00007ffedcad5000)
-	libshare.so => not found
-	libc.so.6 => /usr/lib/libc.so.6 (0x00007f7b99a00000)
-	/lib64/ld-linux-x86-64.so.2 => /usr/lib64/ld-linux-x86-64.so.2 (0x00007f7b99c90000)
-```
-
-Library is not in search path
-```
-$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:`pwd`
-$ ./use_share
-$ ldd use_share
-	linux-vdso.so.1 (0x00007fffc415c000)
-	libshare.so => /your/path/libshare.so (0x00007f48b03c6000)
-	libc.so.6 => /usr/lib/libc.so.6 (0x00007f48b0000000)
-	/lib64/ld-linux-x86-64.so.2 => /usr/lib64/ld-linux-x86-64.so.2 (0x00007f48b03d2000)
-```
-
-Other way is to set custom library search location. Lets set it to search in current directory.
-And no need to modify LD_LIBRARY_PATH
-
-```
-$ gcc use_share.c -o use_share -L. -lshare -Wl,-rpath=./
-$ ldd ./use_share
-	linux-vdso.so.1 (0x00007fff5c964000)
-	libshare.so => ./libshare.so (0x00007f791000f000)
-	libc.so.6 => /usr/lib/libc.so.6 (0x00007f790fc00000)
-	/lib64/ld-linux-x86-64.so.2 => /usr/lib64/ld-linux-x86-64.so.2 (0x00007f791001b000)
-```
-
-So now executable runs libshare from local directory. Ofc there is possible to install shared library into systems /usr/lib
-
-### Static library
-
-
-
-
-### Static binary
-
-Static binary don't use any shared libraries, and its possible to built it once and distribute on other platforms
-without need to install dependencies. 
-
-
-```c
-#include <stdio.h>
-#include <stdlib.h>
-
-int main(int argc, char **argv) {
-	return 0;
-}
-```
-
-First step to compile file and see that is dynamically lined
-```
-$ gcc static_elf.c -o static_elf
-$ file static_elf
-static_elf: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=bc6ac706075874858e1c4a8accf77e704f4ea25a, for GNU/Linux 4.4.0, with debug_info, not stripped
-$ ldd ./static_elf
-	linux-vdso.so.1 (0x00007ffccef49000)
-	libc.so.6 => /usr/lib/libc.so.6 (0x00007fcbb8800000)
-	/lib64/ld-linux-x86-64.so.2 => /usr/lib64/ld-linux-x86-64.so.2 (0x00007fcbb8b63000)
-
-```
-
-After adding static option we can verify that tools now report it as statically linked. Size of binary increased as all functions
-that require to run executable are now contained in binary.
-
-```
-$ gcc static_elf.c -static -o static_elf
-$ file static_elf
-static_elf: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, BuildID[sha1]=c54d2e4d2a3d11fe920bee9a44af045c6f67ab56, for GNU/Linux 4.4.0, with debug_info, not stripped
-$ ldd static_elf 
-	not a dynamic executable
-```
-
-Statically compiled file should work on most platforms.
-
-
-
-### Atomic
-HERE
-
-### Multithreading
-HERE
-
-
-<!--
-### stdin,stdout,stderr
-### Styles
-
---->
-
-
-
-
-## Basic usage
-
-### File manipulation with libc
-
-Create file open data using libc functions
-
-```c
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-int main() {
-	FILE *f = fopen("file.txt","w+");
-	char *s = "Hello";
-	fwrite(s,1,strlen(s),f);
-	fclose(f);
-}
-```
-
-Open file and read data back
-
-```c
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-int main() {
-	FILE *f = fopen("file.txt","r");
-	char buf[128];
-	int r;
-	r = fread(buf,1,128,f);
-	buf[r] = 0;
-	printf("->%s\n",buf,r);
-	fclose(f);
-}
-```
-
-### File manipulation with syscalls
-
-Now lets do the same without using libc functions using syscall function to directly use syscalls,
-its also straightforward to rewrite example for assembly.
-
-```c
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/syscall.h>
-#include <string.h>
-
-int main(void) {
-  int fd = syscall(SYS_open, "sys.txt", O_CREAT|O_WRONLY, S_IRWXU|S_IRGRP|S_IXGRP);
-  char s[] = "hello sycall\n";
-  syscall(SYS_write, fd, s, strlen(s));
-  syscall(SYS_close, fd);
-  return 0;
-}
-```
-
-
-Read data from file
-
-```c
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/syscall.h>
-#include <string.h>
-
-int main(void) {
-  int fd = syscall(SYS_open, "sys.txt", O_RDONLY);
-  char s[128];
-  int r = syscall(SYS_read, fd, s, 128);
-  s[r] = 0;
-  syscall(SYS_close, fd);
-  syscall(SYS_write, 0, s, r);
-  return 0;
-}
-```
-
-## Advanced topics
-
-### Kernel module
-
-Linux kernel, macos kernel and *BSD's kernels written in C, 
-so there is possibility to write kernel modules in C for some of those.
-
-Example will not match some specific things to local distribution.
-
-```c
-
-```
-
-http://main.lv/writeup/kernel_hello_world.md
-
-### Linking
-
-Linking is one of the most interesting parts of compiling of C code. When object file is created
-it contains functions and variables that can be of different type. And linking tries to resolve
-all of those. So there is possible to have fun with linking and content of object files.
-
-
-First example is piece of C code that can be compiled to object file, but it will not able to 
-resolve to executable.
-```
-gcc -c link_elf.c
-```
-```c
-int main() {
-	fun1();
-	fun2();
-}
-```
-So we can see that fun1 and fun2 are marked as undefined in object file. If we try compile it will not able to find those.
-So lets create one more object file
-```
-$ readelf -a link_elf.o
-
-Symbol table '.symtab' contains 6 entries:
-   Num:    Value          Size Type    Bind   Vis      Ndx Name
-     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
-     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS link_elf.c
-     2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1 .text
-     3: 0000000000000000    31 FUNC    GLOBAL DEFAULT    1 main
-     4: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND fun1
-     5: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND fun2
-
-```
-__link_fun1.c__
-```c
-void fun1() {
-	printf("Hello fun1\n");
-}
-void fun2() {
-	printf("Hello fun2\n");
-}
-```
-
-So now we have object file with funtions that are defined. and we see that its now have undefine pritnf/puts function there.
-
-```
-readelf -a link_fun1.o
-Symbol table '.symtab' contains 7 entries:
-   Num:    Value          Size Type    Bind   Vis      Ndx Name
-     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
-     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS link_fun1.c
-     2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1 .text
-     3: 0000000000000000     0 SECTION LOCAL  DEFAULT    5 .rodata
-     4: 0000000000000000    22 FUNC    GLOBAL DEFAULT    1 fun1
-     5: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND puts
-     6: 0000000000000016    22 FUNC    GLOBAL DEFAULT    1 fun2
-
-```
-
-we can merge both of those files together
-```shell
-gcc -o link_elf link_elf.o link_fun1.o
-```
-The function in object files dont have any idea about input output types. That why anything can be linked that just match name
-lets rewrite code like this
-
-```c
-int fun1(int i) {
-	printf("Hello fun1\n");
-}
-int fun2(int i) {
-	printf("Hello fun2\n");
-}
-```
-And this links without issue.  Theat this as 2 sets that are merge together only few thins know when linking things. 
-Return type, and function arguments arent exposed when object file is created.
-
-Functions can have aliases.
-
-__link_fun2.c__
-
-```c
-static void fun2()  {
-	printf("hello 2\n");
-} __attribute__ ((alias("fun1")));
-```
-
-Now function is local.
-
-```
-Symbol table '.symtab' contains 6 entries:
-   Num:    Value          Size Type    Bind   Vis      Ndx Name
-     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
-     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS link_fun2.c
-     2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1 .text
-     3: 0000000000000000     0 SECTION LOCAL  DEFAULT    5 .rodata
-     4: 0000000000000000    22 FUNC    LOCAL  DEFAULT    1 fun2
-     5: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND puts
-```
-
-Lets compile all object to executable. And the function fun2 isnt used in this case, 
-
-
-
-```
-$ gcc link_fun1.o link_fun2.o link_elf.o -o link_elf
-$ ./link_elf
-Hello fun1
-Hello fun2
-
-```
-
-
-
-lets witch aliasing between 2 functions **fun2**
-
-
-```
-link_fun1.o
-     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
-     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS link_fun1.c
-     2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1 .text
-     3: 0000000000000000     0 SECTION LOCAL  DEFAULT    5 .rodata
-     4: 000000000000001d    29 FUNC    LOCAL  DEFAULT    1 fun2
-     5: 0000000000000000    29 FUNC    GLOBAL DEFAULT    1 fun1
-     6: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND puts
-
-link_fun2.o
-     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
-     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS link_fun2.c
-     2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1 .text
-     3: 0000000000000000     0 SECTION LOCAL  DEFAULT    5 .rodata
-     4: 0000000000000000    22 FUNC    GLOBAL DEFAULT    1 fun2
-     5: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND puts
-
-```
-
-```
-$ gcc link_fun1.o link_fun2.o link_elf.o -o link_elf
-$ ./link_elf
-Hello fun1
-hello 2
-```
-
-So all of this plays role in linking object files.
-There is more interesting utilit called ld its doing things on lower level then gcc.
-
-
-### Extern
-
-### Attributes
-PASS
-### Creating shared library
-PASS
-### Create static libraries
-PASS
-### Join all objects together 
-PASS 
-### Compile with musl
-
-The libc is not the only option as standard c library, there is few others one of them is musl
-
-```
-$ musl-gcc hello_world.c -o hello_world
-$ file ./hello_world
-hello_world_musl: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib/ld-musl-x86_64.so.1, not stripped
-```
-
-
-### Inspect elf files
-
-There is few utilities that help to check if elf file is ok.
-
-ldd show what kind of shared libraries elf will try to load
-
-```
-$ ldd hello_world
-	linux-vdso.so.1 (0x00007fffcb2ae000)
-	libc.so.6 => /usr/lib/libc.so.6 (0x00007ffb80c00000)
-	/lib64/ld-linux-x86-64.so.2 => /usr/lib64/ld-linux-x86-64.so.2 (0x00007ffb80fb9000)
-
-```
-
-Readelf allows to inspect content of elf files, headers and interpret values in headers.
-In few example above we allready used that feature to check content of compiled objectfiles.
-
-```
-$ readelf -s ./hello_world
-Symbol table '.symtab' contains 37 entries:
-   Num:    Value          Size Type    Bind   Vis      Ndx Name
-     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
-     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS abi-note.c
-     2: 000000000000039c    32 OBJECT  LOCAL  DEFAULT    4 __abi_tag
-     3: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS init.c
-     4: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crtstuff.c
-     5: 0000000000001070     0 FUNC    LOCAL  DEFAULT   14 deregister_tm_clones
-     6: 00000000000010a0     0 FUNC    LOCAL  DEFAULT   14 register_tm_clones
-     7: 00000000000010e0     0 FUNC    LOCAL  DEFAULT   14 __do_global_dtors_aux
-     8: 0000000000004030     1 OBJECT  LOCAL  DEFAULT   25 completed.0
-     9: 0000000000003df0     0 OBJECT  LOCAL  DEFAULT   20 __do_global_dtor[...]
-    10: 0000000000001130     0 FUNC    LOCAL  DEFAULT   14 frame_dummy
-    11: 0000000000003de8     0 OBJECT  LOCAL  DEFAULT   19 __frame_dummy_in[...]
-    12: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS hello_world.c
-    13: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS crtstuff.c
-    14: 00000000000020b0     0 OBJECT  LOCAL  DEFAULT   18 __FRAME_END__
-    15: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS 
-    16: 0000000000003df8     0 OBJECT  LOCAL  DEFAULT   21 _DYNAMIC
-    17: 0000000000002010     0 NOTYPE  LOCAL  DEFAULT   17 __GNU_EH_FRAME_HDR
-    18: 0000000000004000     0 OBJECT  LOCAL  DEFAULT   23 _GLOBAL_OFFSET_TABLE_
-    19: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_mai[...]
-    20: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_deregisterT[...]
-    21: 0000000000004020     0 NOTYPE  WEAK   DEFAULT   24 data_start
-    22: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND puts@GLIBC_2.2.5
-    23: 0000000000004030     0 NOTYPE  GLOBAL DEFAULT   24 _edata
-    24: 0000000000001154     0 FUNC    GLOBAL HIDDEN    15 _fini
-    25: 0000000000004020     0 NOTYPE  GLOBAL DEFAULT   24 __data_start
-    26: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__
-    27: 0000000000004028     0 OBJECT  GLOBAL HIDDEN    24 __dso_handle
-    28: 0000000000002000     4 OBJECT  GLOBAL DEFAULT   16 _IO_stdin_used
-    29: 0000000000004038     0 NOTYPE  GLOBAL DEFAULT   25 _end
-    30: 0000000000001040    38 FUNC    GLOBAL DEFAULT   14 _start
-    31: 0000000000004030     0 NOTYPE  GLOBAL DEFAULT   25 __bss_start
-    32: 0000000000001139    26 FUNC    GLOBAL DEFAULT   14 main
-    33: 0000000000004030     0 OBJECT  GLOBAL HIDDEN    24 __TMC_END__
-    34: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND _ITM_registerTMC[...]
-    35: 0000000000000000     0 FUNC    WEAK   DEFAULT  UND __cxa_finalize@G[...]
-    36: 0000000000001000     0 FUNC    GLOBAL HIDDEN    12 _init
-```
-
-### No standard library
-
-Lets write hello world without libc.
-
-__noc.c__
-```c
-void _start() {
-
-}
-```
-
-```
-$ gcc -c noc.c
-$ ld -dynamic-linker /lib/ld-linux.so.2 noc.o -o noc
-$ file noc
-noc: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
-```
-
-Next step to make it more working then segfaulting.
-
-```c
-void _start() {
- asm ( \
-      "movl $1,%eax\n" \
-      "xor %ebx,%ebx\n" \
-      "int $128\n" \
-    );
-}
-```
-
-Now this is all about calling the syscalls
-
-Lets print the message
-```c
-signed int write(int fd, const void *buf, unsigned int size)
-{
-    signed int ret;
-    asm volatile
-    (
-        "syscall"
-        : "=a" (ret)
-        //                 EDI      RSI       RDX
-        : "0"(1), "D"(fd), "S"(buf), "d"(size)
-        : "rcx", "r11", "memory"
-    );
-    return ret;
-}
-
-void _start() {
-	write(1,"no libc",8);
- asm ( \
-      "movl $1,%eax\n" \
-      "xor %ebx,%ebx\n" \
-      "int $128\n" \
-    );
-}
-```
-
-http://main.lv/writeup/making_c_executables_smaller.md
-
-### Memory leaks
-
-Memory leaks is cruitial part of C language. Default case when they are detected are
-when allocated memory wasn free'd after use. If amount of this type of memory increasing then
-its can eventually fill whole memory and system will be unresponsive. Here is simple example
-how memory leak created and how to detect it.
-
-```c
-#include <stdlib.h>
-
-int main() {
-
-	char *ptr = malloc(12);
-
-	return 0;
-}
-```
-
-The best way to detect it to use valgrind. 
-
-```
-$ valgrind ./malloc
-
-==778== HEAP SUMMARY:
-==778==     in use at exit: 12 bytes in 1 blocks
-==778==   total heap usage: 2 allocs, 1 frees, 1,036 bytes allocated
-```
-
-There is seen 2 allocs and 1 free. But we see that 12bytes after exit. So our created leak is detected.
-More complex example. So now we created leaking function and we called it 5 times. But in larger code
-base it would be nice to see location of leaks.
-
-```c
-#include <stdlib.h>
-
-int* mem_alloc(int sz) {
-	int *ret=NULL;
-
-	if (sz < 0) {
-		return NULL; 
-	}
-
-	ret = malloc(sz*sizeof(int));
-
-	if (sz>10) {
-		return NULL;
-	}
-
-	return ret;
-
-}
-
-int main() {
-
-	mem_alloc(0);
-
-	free(mem_alloc(1));
-
-	mem_alloc(100); 
-
-	free(mem_alloc(2));
-
-	mem_alloc(10);
-
-	return 0;
-}
-```
-
-There is 3 blocks that leaks, and we see where its comming from there is possible to guess but it would better
-to have position of where leak located.
-
-```
-valgrind --leak-check=full --track-origins=yes --log-file=log.txt ./memleak2
-
-==4974== HEAP SUMMARY:
-==4974==     in use at exit: 440 bytes in 3 blocks
-==4974==   total heap usage: 5 allocs, 2 frees, 452 bytes allocated
-==4974== 
-==4974== 0 bytes in 1 blocks are definitely lost in loss record 1 of 3
-==4974==    at 0x4841888: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
-==4974==    by 0x109179: mem_alloc (in /home/fam/prog/c/undefined_c/memleak2)
-==4974==    by 0x10919E: main (in /home/fam/prog/c/undefined_c/memleak2)
-==4974== 
-==4974== 40 bytes in 1 blocks are definitely lost in loss record 2 of 3
-==4974==    at 0x4841888: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
-==4974==    by 0x109179: mem_alloc (in /home/fam/prog/c/undefined_c/memleak2)
-==4974==    by 0x1091D6: main (in /home/fam/prog/c/undefined_c/memleak2)
-==4974== 
-==4974== 400 bytes in 1 blocks are definitely lost in loss record 3 of 3
-==4974==    at 0x4841888: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
-==4974==    by 0x109179: mem_alloc (in /home/fam/prog/c/undefined_c/memleak2)
-==4974==    by 0x1091BA: main (in /home/fam/prog/c/undefined_c/memleak2)
-==4974== 
-==4974== LEAK SUMMARY:
-==4974==    definitely lost: 440 bytes in 3 blocks
-==4974==    indirectly lost: 0 bytes in 0 blocks
-==4974==      possibly lost: 0 bytes in 0 blocks
-==4974==    still reachable: 0 bytes in 0 blocks
-==4974==         suppressed: 0 bytes in 0 blocks
-```
-
-Add compilation option __g3__
-
-```
-gcc -g3 memleak2.c -o memleak2
-```
-
-Now it shows source lines and trace from where the leaking code where called. Thats looks better now.
-
-```
-valgrind --leak-check=full --track-origins=yes --log-file=log.txt ./memleak2
-
-==5073== HEAP SUMMARY:
-==5073==     in use at exit: 440 bytes in 3 blocks
-==5073==   total heap usage: 5 allocs, 2 frees, 452 bytes allocated
-==5073== 
-==5073== 0 bytes in 1 blocks are definitely lost in loss record 1 of 3
-==5073==    at 0x4841888: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
-==5073==    by 0x109179: mem_alloc (memleak2.c:10)
-==5073==    by 0x10919E: main (memleak2.c:22)
-==5073== 
-==5073== 40 bytes in 1 blocks are definitely lost in loss record 2 of 3
-==5073==    at 0x4841888: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
-==5073==    by 0x109179: mem_alloc (memleak2.c:10)
-==5073==    by 0x1091D6: main (memleak2.c:30)
-==5073== 
-==5073== 400 bytes in 1 blocks are definitely lost in loss record 3 of 3
-==5073==    at 0x4841888: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
-==5073==    by 0x109179: mem_alloc (memleak2.c:10)
-==5073==    by 0x1091BA: main (memleak2.c:26)
-==5073== 
-==5073== LEAK SUMMARY:
-==5073==    definitely lost: 440 bytes in 3 blocks
-==5073==    indirectly lost: 0 bytes in 0 blocks
-==5073==      possibly lost: 0 bytes in 0 blocks
-==5073==    still reachable: 0 bytes in 0 blocks
-==5073==         suppressed: 0 bytes in 0 blocks
-==5073== 
-```
-
-
-### Code coverage
-
-Compile file with extra flags and generate gcov file output.
-Ther is only one branch not used. Coverage should show with part isnt used.
-
-```c
-#include <stdio.h>
-
-int fun1(int a) {
-	if (a < 0) {
-		printf("Smaller then zero\n");
-	} 
-	if (a==0) {
-		printf("Equails to zero\n");
-	}
-	if (a>0) {
-		printf("Bigger then zero\n");
-	}
-}
-
-int main() {
-
-	printf("Start\n");
-	fun1(0);
-	fun1(1);
-
-	return 0;
-}
-```
-
-```
-$ gcc -fprofile-arcs -ftest-coverage coverage.c -o coverage
-$ gcov ./coverage
-File 'coverage.c'
-Lines executed:92.31% of 13
-Creating 'coverage.c.gcov'
-
-Lines executed:92.31% of 13
-
-```
-
-Gcov file content. So we scant see with line wasnt executed. 
-
-```c
-        -:    0:Source:coverage.c
-        -:    0:Graph:coverage.gcno
-        -:    0:Data:coverage.gcda
-        -:    0:Runs:1
-        -:    1:#include <stdio.h>
-        -:    2:
-        2:    3:int fun1(int a) {
-        2:    4:	if (a < 0) {
-    #####:    5:		printf("Smaller then zero\n");
-        -:    6:	} 
-        2:    7:	if (a==0) {
-        1:    8:		printf("Equails to zero\n");
-        -:    9:	}
-        2:   10:	if (a>0) {
-        1:   11:		printf("Bigger then zero\n");
-        -:   12:	}
-        2:   13:}
-        -:   14:
-        1:   15:int main() {
-        -:   16:
-        1:   17:	printf("Start\n");
-        1:   18:	fun1(0);
-        1:   19:	fun1(1);
-        -:   20:
-        1:   21:	return 0;
-        -:   22:}
-```
-
-### Profiling
-
-Some parts of code can take substantial amount of time and those parts need to be identified.
-
-```c
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-
-void slow_sin() {
-	float r=0.0f;
-	for (int i=0;i<10000000;i++) {
-		r += sinf(M_PI/8);
-	}
-}
-
-void slower_sin() {
-	double r=0.0f;
-	for (int i=0;i<10000000;i++) {
-		r += sin(M_PI/8);
-	}
-}
-
-void fast_sin() {
-	float pre_calc = sinf(M_PI/8);
-	float r = 0.0f;
-	for (int i=0;i<10000000;i++) {
-		r += pre_calc;
-	}
-}
-
-int main() {
-	slow_sin();
-	slower_sin();
-	fast_sin();
-}
-```
-
-Compile and rung with profiling
-
-```
-gcc -pg perf_speed.c -o perf_speed -lm
-./perf_speed
-gprof perf_speed gmon.cov
-```
-
-### Sanitizer
-
-C as a greate language have good features in standart such as undefined behaviour. And 
-also there is possible to overwrite any data you whant with your code. One of the favorite
-mistake is to write some buffer overruns. Its possible to catch this type of errors with
-stack protection
-
-So in code belove there is possible to write in to array of size 8 more then 8 characters. This is because the is no any boundry check.
-C runtime will be able to detect this kind of things.
-
-
-```c
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-void fun(char *str,int size) {
-	char local_var[8];
-	memcpy(local_var, str, size);
-	printf("Whats inside a stack? %s\n",local_var);
-}
-
-int main() {
-	char some_str1[] = "Hello!";
-	char some_str2[] = "Hello all!!!";
-
-	fun(some_str1,strlen(some_str1));
-	fun(some_str2,strlen(some_str2));
-}
-```
-
-```
-Whats inside a stack? Hello!
-Whats inside a stack? Hello all!!!
-*** stack smashing detected ***: terminated
-fish: Job 1, './stack_overrun' terminated by signal SIGABRT (Abort)
-```
-
-If this isnt happening there is possible to add __-fstack-protector__ to compile flags.
-
-C have whole list of undefined behaviours incorporated in standard
-https://en.cppreference.com/w/c/language/behavior
-
-
-
-functions __f__ variable __a__ isnt initialized so its undefined behaviour but there still will be some value. Run few
-times and each time it returns new value when __f(0)__.
-```c
-#include <stdio.h>
-
-size_t f(int x)
-{
-    size_t a;
-    if(x) // either x nonzero or UB
-        a = 42;
-    return a; 
-}
-
-int main() {
-	printf("%d\n",f(0));
-	printf("%d\n",f(1));
-	printf("%d\n",f(42));
-}
-```
-
-Division by zero. Function __f__ dont check if divisor is 0. Programm going to abort.
-add flag __-fsanitize=integer-divide-by-zero__ and it will be detected at runtime
-
-```c
-#include <stdio.h>
-
-size_t f(int x)
-{
-    return 10/x; 
-}
-
-int main() {
-	printf("%d\n",f(0));
-	printf("%d\n",f(1));
-	printf("%d\n",f(42));
-}
-```
-
-```
-undefined_b.c:5:14: runtime error: division by zero
-fish: Job 1, './undefined_b' terminated by signal SIGFPE (Floating point exception)
-```
-
-<!--
-### FARMA-C
---->
-
-
-
-
-### Write plugins
-### Preload library
-
-
-## Embedding C
-
-Most of the programming languages support embeding C. As C language have where simple
-functiong naming when its mangled to object format it makes it easy target when 
-linking with other languages. Most of other languages have incompatible naming for
-functions when compiled to binary. 
-
-### Embed in C++
-
-__lib.h__
-```c
-#include <stdlib.h>
-#include <stdio.h>
-
-int fun_secret_1();
-```
-
-__lib.c__
-```c
-#include "lib.h"
-
-int fun_secret_1() {
-	printf("Hello from C\n");
-	return -1;
-}
-```
-
-First thing to notice is when file is compiled with C++ is that the name of the function are in different format
-then when its compiled with C. 
-```
-$ g++ -c lib.c
-$ readelf -s lib.o
-Symbol table '.symtab' contains 6 entries:
-   Num:    Value          Size Type    Bind   Vis      Ndx Name
-     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
-     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS lib.c
-     2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1 .text
-     3: 0000000000000000     0 SECTION LOCAL  DEFAULT    5 .rodata
-     4: 0000000000000000    26 FUNC    GLOBAL DEFAULT    1 _Z12fun_secret_1v
-     5: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND puts
-
-```
-
-Lets tell C++ that file is C language by adding **extern "c"**
-
-__lib.h__
-```c
-#include <stdlib.h>
-#include <stdio.h>
-
-extern "C" {
-
-int fun_secret_1();
-
-}
-```
-
-__lib.c__
-```c
-#include "lib.h"
-
-extern "C" {
-
-int fun_secret_1() {
-	printf("Hello from C\n");
-	return -1;
-}
-
-}
-```
-
-Now compiled object file have C function names. 
-
-```
-$ g++ lib.c -c
-$ readelf -s lib.o
-
-Symbol table '.symtab' contains 6 entries:
-   Num:    Value          Size Type    Bind   Vis      Ndx Name
-     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
-     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS lib.c
-     2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1 .text
-     3: 0000000000000000     0 SECTION LOCAL  DEFAULT    5 .rodata
-     4: 0000000000000000    26 FUNC    GLOBAL DEFAULT    1 fun_secret_1
-     5: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND puts
-
-```
-
-__cppembed.cpp___
-```cpp
-#include "lib.h"
-
-int main() {
-	fun_secret_1();
-}
-```
-
-Doing oposite way running C++ from C  
-[/writeup/wraping_c_plus_plus_exceptions_templates_and_classes_in_c.md](/writeup/wraping_c_plus_plus_exceptions_templates_and_classes_in_c.md)
-
-### Embed in Go
-
-__lib.h__
-```c
-#include <stdlib.h>
-#include <stdio.h>
-
-int fun_secret_1();
-```
-__lib.c__
-```c
-#include "lib.h"
-
-int fun_secret_1() {
-	printf("Hello from C\n");
-	return -1;
-}
-```
-
-__main.go__
-```go
-package main
-// #cgo CFLAGS: -g -Wall
-// #include <stdlib.h>
-// #include "lib.h"
-import "C"
-import (
-	"fmt"
-	
-)
-func main() {
-	fmt.Println("Start program")
-	C.fun_secret_1()
-	fmt.Println("End program")
-}
-```
-
-```
-go build
-```
-
-[https://karthikkaranth.me/blog/calling-c-code-from-go/](https://karthikkaranth.me/blog/calling-c-code-from-go/)
-
-
-### Embed in Swift
-
-[/writeup/linux_hello_world_in_swift.md](/writeup/linux_hello_world_in_swift.md)
-
-### Embed in Rust
-
-__lib.c__
-```c
-#include <stdio.h>
-#include <stdlib.h>
-
-int fun_secret_1() {
-	printf("Hello from C\n");
-	return -1;
-}
-```
-
-```rust
-extern "C" {
-	fn fun_secret_1();
-}
-
-//rustc main.rs -o hello
-fn main() {
-	println!("Start program");
-	unsafe {fun_secret_1()}
-	println!("End program");
-}
-```
-
-Compile with
-
-```
-gcc -c lib.c
-gcc -shared lib.o -o liblib.so
-rustc main.rs -l lib -L . -o hello -C link-arg="-Wl,-rpath=./"
-```
-
-[https://dev.to/xphoniex/how-to-call-c-code-from-rust-56do](https://dev.to/xphoniex/how-to-call-c-code-from-rust-56do)
-
-### Lua in C
-
-[/writeup/embedding_lua_in_c.md](/writeup/embedding_lua_in_c.md)  
-
-### Python in C
-
-
-
-## Multiplatform
-
-### Different flags
-
-### Check architecture
-
-
-
-```c
-```
-
-### AArch64
-
-https://snapshots.linaro.org/gnu-toolchain/13.0-2022.08-1/aarch64-linux-gnu/
-
-download any of the version of gcc and extract
-
-Add bin directory location to env variable PATH
-
-```
-export PATH=$PATH:`pwd`
-```
-
-___main.c__
-```c
-#include <stdio.h>
-
-int main() {
-	printf("Hello world arm64\n");
-}
-```
-
-```
-$ arch64-linux-gnu-gcc main.c -o main
-$ ./main
-qemu-aarch64: Could not open '/lib/ld-linux-aarch64.so.1': No such file or directory
-$ file ./main
-./main: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux-aarch64.so.1, BuildID[sha1]=12448d90030e2ad23dbe6b7bc82a4fa7b7de9659, for GNU/Linux 3.7.0, with debug_info, not stripped
-```
-
-Download sysroot image from linaro page.
-With running 
-
-```
-strace ./main
-```
-
-It showed that searched path for libraries are in
-
-```
-/usr/gnemul/qemu-aarch64/lib/
-```
-
-Found missing libc and ld-linux-aarch64 inside sysroot archive and copied at searched location amd now AArch64 binary is running.
-
-```
-$ ./main
-Hello world arm64
-```
-
-### AVR8
-
-AVR is 8bit CPU that is quite popular for hobbiest. As baremetal device its doesnt have full libc support,
-and needs some setup before its possible to do basics things with it.
-
-__avr_echo.c__
-```c
-#include <avr/io.h>
-
-#define FOSC 16000000UL
-#define BAUD 9600
-#define MYUBRR FOSC/16/BAUD-1
-
-void USART_Init( unsigned int ubrr)
-{
-	UBRRH = (unsigned char)(ubrr>>8);
-	UBRRL = (unsigned char)ubrr;
-	UCSRB = (1<<RXEN)|(1<<TXEN);
-	UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);
-}
-
-int main()
-{
-	char c;
-	USART_Init( MYUBRR );
-	while(1)
-	{
-		while ( !(UCSRA & (1<<RXC))){};
-		c = UDR;
-		while (!(UCSRA & (1<<UDRE))){};
-		UDR = c;
-	}
-	return 0;
-}
-```
-
-```
-avr-gcc avr_echo.c -mmcu=atmega16 -Wall -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -o avr_echo.out
-```
-
-Next steps woule be to programm it, in case you have ISPv2 programmer and ATmega16 chip
-
-```bash
-avr-objdump -s --disassemble avr_echo.out > avr_echo.s
-avr-objcopy -j .text -O ihex avr_echo.out avr_echo.hex
-avrdude -pm16 -cavrispv2 -Pusb -U flash:w:avr_echo.hex
-```
-
-### Emscripten
-
-[/writeup/web_assembly_sdl_example.md](/writeup/web_assembly_sdl_example.md)
-
-
-
-
-
-
-