---
# System prepended metadata

title: 'Lista 8 (29.04.2021), grupa pwit'
tags: [pwit, ask21, ćwiczenia]

---

# Lista 8 (29.04.2021), grupa pwit

###### tags: `ask21` `ćwiczenia` `pwit`

## Deklaracje

Gotowość rozwiązania zadania należy wyrazić poprzez postawienie X w odpowiedniej kolumnie! Jeśli pożądasz zreferować dane zadanie (co najwyżej jedno!) w trakcie dyskusji oznacz je znakiem ==X== na żółtym tle.

**UWAGA: Tabelkę wolno edytować tylko wtedy, gdy jest na zielonym tle!**

Tabelka zawiera tylko osoby zapisane do grupy. Osoby oczekujące proszone są o wpisanie się do osobnej tabelki poniżej.


:::danger
|                      | 1   | 2   | 3   | 4   |  5  |  6  | 7   |  8  |
| --------------------:| --- | --- | --- | --- |:---:|:---:| --- |:---:|
|Wojciech Adamiec      |  X  |  X  |  X  |  X  |     |     |     |     |
|Kacper Bajkiewicz     |  X  |  X  |  X  |==X==|  X  |  X  |     |     |
|Bartłomiej Hildebrandt|  X  |  X  |  X  |  X  |  X  |  X  |     |     |
|Dominik Komła         |  X  |  X  |  X  |  X  |  X  |     |     |     |
|Aleksandra Kosińska   |  X  |  X  |  X  |  X  |  X  |  X  |     |     |
|Oleś Kulczewicz       |  X  |  X  |  X  |  X  |     |     |     |     |
|Damian Lukas          |  X  |  X  |  X  |  X  |     |     |     |     |
|Michał Mikołajczyk    |  X  |  X  |  X  |  X  |     |     |     |     |
|Mateusz Opala         |   X  |  X   |  X   |  X   |  X   |     |     |     |
|Łukasz Orawiec        |   X |  X  |   X |  X  |     |     |     |     |
|Szymon Pielat         |  X  |  X  |  X  |  X  |     |     |     |     |
|Łukasz Pluta          |  X  |  X  |  X  |  X  |   X |     |     |     |
|Kamil Puchacz         |  X  |  X  |  X  |  X  |     |     |     |     |
|Magdalena Rzepka      |  X  |  X  |  X  |  X  |  X  |  X  |     |     |
|Cezary Stajszczyk     |  X  |  X  |  X  |  X  |  X  |  X  |     |     |
|Jakub Szajner         |  X  |  X  |  X  |  X  |  ==X==  |  X  |     |     |
|Bartosz Troszka       |  X   |  X   |  X   |  X   |     |     |     |     |
|Miłosz Urbanik        |  X  |  X  |  X  |  X  |  X  |     |     |     |

:::




## Zadanie 1
:::info
Autor: Oleś Kulczewicz
:::

`ELF` - to format plików dla plików objektów, który składa się z dwóch sekcji:
- Linking view: Section Header Table (SHT)
- Execution view: Program Header Table (PHT)


```
extern int buf[];

int *bufp0 = &buf[0];
static int *bufp1;

static void incr() {
  static int count = 0;
  count++;
}

void swap() {
  int temp;
  incr();
  bufp1 = &buf[1];
  temp = *bufp0;
  *bufp0 = *bufp1;
  *bufp1 = temp;
}

```

W wyniku odpalenia komendy `readelf -t -s swap.o`  dostajemy:

```There are 11 section headers, starting at offset 0x2a0:

Section Headers:
  [Nr] Name
       Type              Address          Offset            Link
       Size              EntSize          Info              Align
       Flags
  [ 0] 
       NULL                   NULL             0000000000000000  0000000000000000  0
       0000000000000000 0000000000000000  0                 0
       [0000000000000000]: 
  [ 1] .text
       PROGBITS               PROGBITS         0000000000000000  0000000000000040  0
       000000000000002a 0000000000000000  0                 1
       [0000000000000006]: ALLOC, EXEC
  [ 2] .rela.text
       RELA                   RELA             0000000000000000  00000000000001d8  9
       0000000000000060 0000000000000018  1                 8
       [0000000000000040]: INFO LINK
  [ 3] .data
       PROGBITS               PROGBITS         0000000000000000  0000000000000070  0
       0000000000000008 0000000000000000  0                 8
       [0000000000000003]: WRITE, ALLOC
  [ 4] .rela.data
       RELA                   RELA             0000000000000000  0000000000000238  9
       0000000000000018 0000000000000018  3                 8
       [0000000000000040]: INFO LINK
  [ 5] .bss
       NOBITS                 NOBITS           0000000000000000  0000000000000078  0
       0000000000000004 0000000000000000  0                 4
       [0000000000000003]: WRITE, ALLOC
  [ 6] .comment
       PROGBITS               PROGBITS         0000000000000000  0000000000000078  0
       0000000000000036 0000000000000001  0                 1
       [0000000000000030]: MERGE, STRINGS
  [ 7] .note.GNU-stack
       PROGBITS               PROGBITS         0000000000000000  00000000000000ae  0
       0000000000000000 0000000000000000  0                 1
       [0000000000000000]: 
  [ 8] .shstrtab
       STRTAB                 STRTAB           0000000000000000  0000000000000250  0
       000000000000004f 0000000000000000  0                 1
       [0000000000000000]: 
  [ 9] .symtab
       SYMTAB                 SYMTAB           0000000000000000  00000000000000b0  10
       0000000000000108 0000000000000018  8                 8
       [0000000000000000]: 
  [10] .strtab
       STRTAB                 STRTAB           0000000000000000  00000000000001b8  0
       0000000000000020 0000000000000000  0                 1
       [0000000000000000]: 

Symbol table '.symtab' contains 11 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000000000     0 SECTION LOCAL  DEFAULT    5 
     2: 0000000000000000     8 FUNC    LOCAL  DEFAULT    1 incr
     3: 0000000000000000     4 OBJECT  LOCAL  DEFAULT    5 count.1835
     4: 0000000000000000     0 SECTION LOCAL  DEFAULT    1 
     5: 0000000000000000     0 SECTION LOCAL  DEFAULT    3 
     6: 0000000000000000     0 SECTION LOCAL  DEFAULT    6 
     7: 0000000000000000     0 SECTION LOCAL  DEFAULT    7 
     8: 0000000000000008    34 FUNC    GLOBAL DEFAULT    1 swap
     9: 0000000000000000     8 OBJECT  GLOBAL DEFAULT    3 bufp0
    10: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND buf
```

- adres symbolu względem początku sekcji: "Value" w `.symtab`
- typ symbolu – tj. `local`, `global`, `extern`: "Bind" w `.symtab`
- rozmiar danych, na które wskazuje symbol: "Size" w `.symtab`
- numer i nazwę sekcji – tj. `.text`, `.data`, `.bss` – do której odnosi się symbol: "Ndx" w `.symtab`: `.text` - 1, `.data` - 3, `.bss` - 5

`strtab` to "String Table", czyli napisy reprezentujące nazwy symboli
`shstrtab` to "Section Header String table", czyli nazwy sekcji


## Zadanie 2
:::info
Autor: Damian Lukas
:::

Dlaczego po uruchomieniu program drukuje ciąg znaków i kończy działanie bez zgłoszenia błędu, skąd pochodzi ta wartość?

```c=
/* mismatch-a.c */
void p2(void);    // symbol silny

int main() {      // symbol silny
    p2();
    return 0;
}
```
```c=
/* mismatch-b.c */
#include <stdio.h>

char main;        // symbol słaby

void p2() {       // symbol silny
    printf("0x%x\n", main);
}
```

Nie pokazuje się żaden błąd, gdyż linker wybiera zawsze silny symbol, tzn. w `mismatch-a.c` mamy zainicjowany `main` oraz jest on globalny, czyli jest silny, a w `mismatch-b.c` nie jest on zainicjowany, więc jest słaby.

Gdybyśmy chcieli przypisać wartość pod zmienną globalną `main` w pliku `mismatch-b.c`, to otrzymalibyśmy błąd `multiple definition of 'main'`, natomiast gdy chcemy przypisać wartość zmiennej `main` w ciele funkcji `p2`, to program skompiluje się poprawnie, jednak po uruchomieniu go otrzymamy `Segmentation fault`.

Wartość zwracana `0x50` jest pierwszą instrukcją w main, można to zobaczyć deasemblując program `mismatch` instrukcją:
```
$ gdb -batch -ex "disassemble/rs main" mismatch
```

Otrzymamy wtedy poniższy kod:
```
Dump of assembler code for function main:
   0x000000000040158c <+0>:     50              push   %rax
   0x000000000040158d <+1>:     e8 cb 05 00 00  callq  0x401b5d <p2>
   0x0000000000401592 <+6>:     31 c0           xor    %eax,%eax
   0x0000000000401594 <+8>:     5a              pop    %rdx
   0x0000000000401595 <+9>:     c3              retq  
End of assembler dump.
```


## Zadanie 3
:::info
Autor: Michał Mikołajczyk
:::

![](https://i.imgur.com/AHRZOZW.png)

#### 1. Liczba plików w bibliotekach libc, libm
```bash=
$ ar t /usr/lib/libc.a | wc -l
1725

$ ar t /usr/lib/libm-2.33.a | wc -l
806
```

#### 2. Wywołanie kompilatora z flagą -g
Flaga -Og służy do optymalizacji w trakcie debugowania, optymalizuje ona wszystko, co nie koliduje z debugowaniem, może być użyta wraz z flagą -g służącą do włączania symboli debugowania w GDB.

Flaga -g nie modyfikuje kodu, ale dodaje wiele nowych sekcji i symboli do pliku relokowalnego.

```bash
diff -y <(readelf -t -s str-a.o) <(readelf -t -s str-a.g.o)
```

#### 3. Bibilioteki współdzielone w pythonie
```bash=
$ readelf -d /usr/bin/python

Dynamic section at offset 0x2df8 contains 24 entries:
Tag        Type                         Name/Value
0x0000000000000001 (NEEDED)             Shared library: [libpython3.9.so.1.0]
0x0000000000000001 (NEEDED)             Shared library: [libc.so.6]
...

$ readelf -d /usr/lib/libpython3.9.so

Dynamic section at offset 0x36bae8 contains 27 entries:
Tag        Type                         Name/Value
0x0000000000000001 (NEEDED)             Shared library: [libpthread.so.0]
0x0000000000000001 (NEEDED)             Shared library: [libdl.so.2]
0x0000000000000001 (NEEDED)             Shared library: [libutil.so.1]
0x0000000000000001 (NEEDED)             Shared library: [libm.so.6]
0x0000000000000001 (NEEDED)             Shared library: [libc.so.6]
...
```
## Zadanie 4
:::info
Autor: Kacper Bajkiewicz
:::

Błąd wyskakuje w linijce:
![](https://i.imgur.com/qk0B7Ao.png)

https://stackoverflow.com/questions/164194/why-do-i-get-a-segmentation-fault-when-writing-to-a-char-s-initialized-with-a

Nieprzypisany string ląduje w sekcji .rodata (która jest tylko readonly), w związku z czym kiedy próbujemy nadpisać wartość tego stringa, to program kończy się z błędem segmentation fault.

Funkcja działająca:
```c=
char *somestr(void) {
    static char[] ret = "Hello, world!";
    return ret;
}
```
Teraz zmienna ret ląduje w sekcji .data, czyli zwracając później wskaźnik na ret jesteśmy w stanie go zmodyfikować (bo str jest kopiowany do tablicy). 

## Zadanie 5
:::info
Autor: Jakub Szajner
:::

```=
bar.o:     file format elf64-x86-64
Sections:
Idx Name          Size      VMA               LMA               File off  Algn
  0 .text         00000000  0000000000000000  0000000000000000  00000040  2**0
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data         00000004  0000000000000000  0000000000000000  00000040  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  2 .bss          0000001e  0000000000000000  0000000000000000  00000050  2**4
                  ALLOC
```
```=
foo.o:     file format elf64-x86-64
Sections:
Idx Name          Size      VMA               LMA               File off  Algn
  0 .text         00000000  0000000000000000  0000000000000000  00000040  2**0
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data         00000008  0000000000000000  0000000000000000  00000040  2**3
                  CONTENTS, ALLOC, LOAD, DATA
  2 .bss          00000011  0000000000000000  0000000000000000  00000050  2**4
                  ALLOC
```
```=
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     7: 0000000000000000    30 OBJECT  GLOBAL DEFAULT    3 dead
     8: 0000000000000000     4 OBJECT  GLOBAL DEFAULT    2 bar
     
     7: 0000000000000000    17 OBJECT  GLOBAL DEFAULT    3 code
     8: 0000000000000000     8 OBJECT  GLOBAL DEFAULT    2 foo
```

Flaga -fno-common umieszcza zmienne niezaincjalozowane w .bss.

Częściowa konsolidacja łączy pliki relokowalne w relokowalny któy potem mozna relokować.

Różnią się różną kolejnością plików.

```=
<  .data          0x0000000000000000        0x8 foo.o
<                 0x0000000000000000                foo
<  .data          0x0000000000000008        0x4 bar.o
<                 0x0000000000000008                bar
---
>  .data          0x0000000000000000        0x4 bar.o
>                 0x0000000000000000                bar
>  *fill*         0x0000000000000004        0x4
>  .data          0x0000000000000008        0x8 foo.o
>                 0x0000000000000008                foo
```

```=
<  .bss           0x0000000000000000       0x11 foo.o
<                 0x0000000000000000                code
<  *fill*         0x0000000000000011        0xf
<  .bss           0x0000000000000020       0x1e bar.o
<                 0x0000000000000020                dead
---
>  .bss           0x0000000000000000       0x1e bar.o
>                 0x0000000000000000                dead
>  *fill*         0x000000000000001e        0x2
>  .bss           0x0000000000000020       0x11 foo.o
>                 0x0000000000000020                code
```

## Zadanie 6
:::info
Autor: Bartłomiej Hildebrandt
:::

> Plik wykonywalny powstały w wyniku kompilacji poniższych plików źródłowych powinien być nie dłuższy niż 1KiB. Na podstawie nagłówka pliku ELF wskaż w zdeasemblowanym pierwszą instrukcję, którą wykona procesor po wejściu do programu. Na podstawie nagłówków programu wskaż pod jaki adres wirtualny zostanie załadowany segment z sekcją «.text».
>
> ![](https://i.imgur.com/kPxHIzq.png)
>
> Zapoznaj się ze skryptem konsolidatora w pliku «main.lds». Na podstawie dokumentacji 1 wyjaśnij jak skrypt kieruje procesem konsolidacji poszczególnych sekcji i tworzeniem nagłówków programu.

**Plik wykonywalny (ang. executable object file - a.out)** - zawiera kod i dane w postaci, którą można skopiować bezpośrednio do pamięci, a następnie wykonać

### Na podstawie nagłówka pliku ELF wskaż w zdeasemblowanym pierwszą instrukcję, którą wykona procesor po wejściu do programu

**Nagłówek pliku ELF** - pierwsza instrukcja wykonywana przez procesor po wejściu do programu, otrzymujemy ją z poniższego polecenia w wierszu `Entry point address`.

`readelf` - wyświetla informacje o pliku obiektowym
Flaga `-h` wyświetla nagłówek pliku.

```bash=
readelf -h main

ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF64
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           Advanced Micro Devices X86-64
  Version:                           0x1
  Entry point address:               0x40012a
  Start of program headers:          64 (bytes into file)
  Start of section headers:          400 (bytes into file)
  Flags:                             0x0
  Size of this header:               64 (bytes)
  Size of program headers:           56 (bytes)
  Number of program headers:         3
  Size of section headers:           64 (bytes)
  Number of section headers:         4
  Section header string table index: 3
```

Możemy też wykorzystać polecenie `objdump -f`.
Flaga `-f` wyświetla informacje podsumowujące z ogólnego nagłówka każdego z plików objfile.

```bash=
objdump -f main

main:     file format elf64-x86-64
architecture: i386:x86-64, flags 0x00000102:
EXEC_P, D_PAGED
start address 0x000000000040012a
```

Instrukcję otrzymamy wykonując polecenie `objdump -d main`
```bash=
objdump -d main | grep 40012a

  40012a:	f3 0f 1e fa          	endbr64 
```

### Na podstawie nagłówków programu wskaż pod jaki adres wirtualny zostanie załadowany segment z sekcją `.text`.

**Segment** - zawiera informacje potrzebne w czasie wykonania, podczas gdy sekcje zawierają informacje potrzebne podczas łączenia.

**Nagłówek programu** - adres wirtualny, pod jakim zostanie załadowany segment z sekcją `.text`, otrzymujemy go z poniższego polecenia w wierszu `Section headers: .text`, w kolumnie `Address`.

Flaga `-S` wyświetla sekcje nagłówka.

Sekcje: 
- `.text` - kod programu
- `.comment` - przechowywuje komentarze na temat wygenerowanego ELF (takie jak wersja kompilatora i platforma wykonawcza)
- `.shstrtab (section header string table)` - przechowuje nazwy sekcji

```bash=
readelf -S main

There are 4 section headers, starting at offset 0x190:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .text             PROGBITS         00000000004000e8  000000e8
       0000000000000062  0000000000000000  AX       0     0     1
  [ 2] .comment          PROGBITS         0000000000000000  0000014a
       000000000000002a  0000000000000001  MS       0     0     1
  [ 3] .shstrtab         STRTAB           0000000000000000  00000174
       000000000000001a  0000000000000000           0     0     1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
  L (link order), O (extra OS processing required), G (group), T (TLS),
  C (compressed), x (unknown), o (OS specific), E (exclude),
  l (large), p (processor specific)
```

### Zapoznaj się ze skryptem konsolidatora w pliku `main.lds`. Na podstawie dokumentacji wyjaśnij jak skrypt kieruje procesem konsolidacji poszczególnych sekcji i tworzeniem nagłówków programu.

**Skrypt konsolidatora** - łączy poszczególne sekcje plików relokowalnych w jedną sekcję o tej samej nazwie.

Plik `main.lds`:

```c=
OUTPUT_FORMAT("elf64-x86-64") // format pliku wyjściowego
OUTPUT_ARCH(i386:x86-64)      // architektura pliku wyjściwego
ENTRY(_start) // entry point address - pierwsza instrukcja do wykonania w programie

/*
 * Program Headers - nagłówki programu opisujące, w jaki sposób program
 * powinien zostać załadowany do pamięci
*/ 
PHDRS // definiujemy jakie nagłówki mają zostać utworzone
{ // name type flags
  code   PT_LOAD FLAGS(5); // PT_LOAD - nagłówek opisujący segment do załadowania z pliku
  rodata PT_LOAD FLAGS(4);
  data   PT_LOAD FLAGS(6);
}
/* 
 * SECTIONS - polecenie, które opisuje układ pamięci pliku wyjściowego 
*/
SECTIONS
{
  . = 0x400000 + SIZEOF_HEADERS; // adres początku sekcji .text
  // symbol kropki to location counter

  .text :            // nazwa sekcji pliku wejściowego
  {
    *(.text .text.*) // regex do matchowania odpowiednich sekcji (wszystkie sekcje .text we wszystkich plikach wejściowych)
  } : code           // nazwa sekcji pliku wyjściowego
  
  /* adres następnej sekcji będzie wyznaczony przez adres początku + rozmiar poprzednich sekcji (w tym przypadku rozmiar sekcji .text)
   * 
   * linker sam zadba o to, aby był prawidłowy alignment poprzez 
   * odpowiednie zwiększanie location countera
  */
  .rodata :          
  {
    *(.rodata .rodata.*)
  } : rodata

  .data : 
  {
    *(.data .data.*)
  } : data

  .bss :
  {
   *(.bss .bss.*)
   *(COMMON)
  } : data

  /DISCARD/ :
  {
    *(.note.gnu.property)
  }
}
```

![](https://i.imgur.com/plVrPCx.png)

#### Konsolidacja

Głównym celem skryptu konsolidatora jest opisanie, w jaki sposób sekcje w plikach wejściowych powinny być mapowane na plik wyjściowy oraz sterować układem pamięci pliku wyjściowego. Konsolidator zawsze używa skryptu konsolidatora, gdy go nie dostarczymy to użyje domyślnego. Gdy użyjemy flagi `-T` to domyślny skrypt zostanie zastąpiony naszym skryptem, co możemy zauważyć w pliku `Makefile`.

```c=
main: even.o odd.o start.o 
	$(LD) $(LDFLAGS) -Tmain.lds -M=$@.map -o $@ $^
	$(STRIP) -s $@
```

Skrypt konsolidatora łączy pliki wejściowe (pliku w formacie obiektowym) w jeden plik wyjściowy (plik wykonywalny w formacie obiektowym). Każdy plik obiektowy zawiera listę sekcji - w skrypcie możemy odnosić się do sekcji w pliku wejściowym jako do sekcji wyjściowej. Każda taka sekcja ma swoją nazwę, rozmiar oraz zawartość. Sekcja może być oznaczona jako ładowalna, co oznacza, że zawartość powinna zostać załadowana do pamięci po uruchomieniu pliku wyjściowego lub może nie mieć zawartości, co oznacza, że pewien obszar pamięci powinien być po prostu zarezerwowany.

Każda sekcja wyjściowa ma dwa adresy - VMA (Virtual Memory Address), czyli adres, który będzie miała sekcja, gdy plik wyjściowy zostanie uruchomiony oraz LMA (Load Memory Address), czyli adres pamięci ładowania, pod którym sekcja zostanie załadowana. Oprócz tego plik taki zawiera również tablicę symboli (z mapowaniem nazw na adresy).

#### Tworzenie nagłówków programu

Kiedy uruchamiamy program ELF, program ładujący odczytuje nagłówki programu, aby dowiedzieć się, jak załadować program. Linker domyślnie tworzy nagłówki programu, ale możemy je również ręcznie zdefiniować poleceniem `PHDRS`, wtedy utworzy on tylko określone nagłówki.


## Zadanie 7
:::info
Autor:
:::


## Zadanie 8
:::info
Autor:
:::



