Lab2

.gitignore

@@ -55,3 +55,6 @@ dkms.conf
 
 *.zip
 *_out
+
+# Python compiled files
+__pycache__

laborator/content/linking/README.md → laborator/content/etapele-compilarii/README.md

@@ -1,6 +1,31 @@
-# Laborator 4: Crearea și analiza unui executabil (2)
+# Laborator 03: Compilare
 
-<!-- Convert to DokuWiki format using Pandoc: pandoc -f markdown_github-hard_line_breaks -t dokuwiki README.md -->
+Etapele prin care trece un program scris în `C` din momentul în care este scris până când este rulat ca un proces sunt, in ordine:
+
+- preprocesare
+- compilare
+- asamblare
+- link editare
+
+În imaginea de mai jos sunt reprezentate si detaliate aceste etape:
+
+![phases-full.png](https://ocw.cs.pub.ro/courses/_media/iocla/laboratoare/phases-full.png?cache=)
+
+## Preprocesare
+
+În cadrul primei etape, cea de `preprocesare` au loc următoarele acțiuni plecând de la fișierul cod sursă:
+* eliminarea comentariilor
+* expandarea directivelor care încep cu simbolul `#`
+    * înlocuirea valorilor corespunzătoare pentru `#define ...`
+    * includerea conținutului fișierelor date ca parametru directivei `#include`
+
+## Compilare
+
+În etapa de `compilare` au loc următoarele subetape:
+* analiza lexicală - verificarea limbajului
+* analiza sintactică - verificarea ordinii cuvintelor (`;` vine la finalul asignării unei variabile)
+* analiza semantică - determinarea sensului codului scris (determinarea contextului variabilelor)
+* generarea de cod în limbaj de asamblare care este o formă human-readable a ce ajunge procesorul să execute efectiv
 
 ## Assembly / Asamblare
 
@@ -223,9 +248,96 @@ Hex dump of section '.rodata':
   0x080484e8 6f726c64 2100                       orld!.
 ```
 
+Majoritatea compilatoarelor oferă opțiunea de a genera și un fișier cu programul scris în limbaj de asamblare.
+
+>**NOTE**: În cazul compilatorului `gcc` este de ajuns să adăugați flag-ul `-S` și vă va genera un
+fișier `*.s` cu codul aferent. În arhiva de `TODO` aveți un exemplu de trecere a unui program
+foarte simplu `hello.c` prin cele patru faze. Îl puteți testa pe un sistem Unix/Linux și pe un sistem Windows cu suport de MinGW.
+```shell
+$ make
+cc  -E -o hello.i hello.c
+cc -Wall -S -o hello.s hello.i
+cc  -c -o hello.o hello.s
+cc  -o hello hello.o
+
+$ ls
+Makefile  hello  hello.c  hello.i  hello.o  hello.s
+
+$ ./hello
+Hello, World!
+
+$ tail -10 hello.i
+
+
+# 5 "hello.c"
+int main(void)
+{
+ puts("Hello, World!");
+
+ return 0;
+}
+
+$ cat hello.s
+	.file	"hello.c"
+	.section	.rodata
+.LC0:
+	.string	"Hello, World!"
+	.text
+	.globl	main
+	.type	main, @function
+main:
+.LFB0:
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	movl	$.LC0, %edi
+	call	puts
+	movl	$0, %eax
+	popq	%rbp
+	.cfi_def_cfa 7, 8
+	ret
+	.cfi_endproc
+.LFE0:
+	.size	main, .-main
+	.ident	"GCC: (Debian 5.2.1-17) 5.2.1 20150911"
+	.section	.note.GNU-stack,"",@progbits
+
+$ file hello.o
+hello.o: ELF 64-bit LSB relocatable, x86-64, [...]
+
+$ file hello
+hello: ELF 64-bit LSB executable, x86-64, [...]
+
+$ objdump -d hello.o
+
+hello.o:     file format elf64-x86-64
+
+
+Disassembly of section .text:
+
+0000000000000000 <main>:
+   0:	55                   	push   %rbp
+   1:	48 89 e5             	mov    %rsp,%rbp
+   4:	bf 00 00 00 00       	mov    $0x0,%edi
+   9:	e8 00 00 00 00       	callq  e <main+0xe>
+   e:	b8 00 00 00 00       	mov    $0x0,%eax
+  13:	5d                   	pop    %rbp
+  14:	c3                   	retq
+```
+
+Pentru a genera sintaxa intel pe 32 de biți, se pot folosi aceste opțiuni:
+```shell
+cc -Wall -m32 -S -masm=intel  -o hello.s hello.i
+```
+
+Dacă programele scrise în limbaje de nivel înalt ajung să fie portate ușor pentru procesoare diferite (arm, powerpc, x86, etc.), cele scrise în limbaj de asamblare sunt implementări specifice unei anumite arhitecturi. Limbaje de nivel înalt reprezintă o formă mai abstractă de rezolvare a unei probleme, din punctul de vedere al unui procesor, motiv pentru care și acestea trebuie traduse în limbaj de asamblare în cele din urmă, pentru a se putea ajunge la un binar care poate fi rulat. Mai multe detalii în laboratoarele următoare.
+
 ## Exerciții
 
-> **NOTE:** În cadrul laboratoarelor vom folosi repository-ul de Git de IOCLA: https://github.com/systems-cs-pub-ro/iocla.
+> **WARNING:** În cadrul laboratoarelor vom folosi repository-ul de Git de IOCLA: https://github.com/systems-cs-pub-ro/iocla.
 > Repository-ul este clonat pe desktopul mașinii virtuale.
 > Pentru a îl actualiza, folosiți comanda `git pull origin master` din interiorul directorului în care se află repository-ul (`~/Desktop/iocla`).
 > Recomandarea este să îl actualizați cât mai frecvent, înainte să începeți lucrul, pentru a vă asigura că aveți versiunea cea mai recentă.
@@ -369,4 +481,4 @@ Rezultatul funcției scrisă în python va fi preluat în codul C și se va afi
 > Puteți să urmăriți și exemplele de [aici](https://www.codeproject.com/Articles/820116/Embedding-Python-program-in-a-C-Cplusplus-code) și/sau [aici](https://www.xmodulo.com/embed-python-code-in-c.html) pentru a vedea cum să preluați rezultatul funcției scrisă în python. De asemenea puteți consulta documentația de [aici](https://docs.python.org/3/c-api/long.html) pentru a vedea cum să faceți conversia rezultatului la un tip de date din C.
 
 > **NOTE:**
-> Atenție la versiunea de python pe care o folosiți; nu este recomandată o anumită versiune însă trebuie să aveți în vedere că în funcție de soluția voastră este posibil să fie nevoie să folosiți versiune specifică. Makefile-ul folosește versiunea **3.9**.
+> Atenție la versiunea de python pe care o folosiți; nu este recomandată o anumită versiune însă trebuie să aveți în vedere că în funcție de soluția voastră este posibil să fie nevoie să folosiți versiune specifică. Makefile-ul folosește versiunea **3.9**.

laborator/content/operatii-memorie-gdb/1-iterate/Makefile

@@ -0,0 +1,2 @@
+PROGNAME := iterate
+include ../../utils/Makefile.generic

laborator/content/operatii-memorie-gdb/1-iterate/iterate.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+
+/**
+ * Afisati adresele elementelor din vectorul "v" impreuna cu valorile
+ * de la acestea.
+ * Parcurgeti adresele, pe rand, din octet in octet,
+ * din 2 in 2 octeti si apoi din 4 in 4.
+ */
+
+void print_char(int *v,int n){
+    printf("MARIME V: %ld, ELEMENTE V: %ld \n", sizeof(v), sizeof(v)/sizeof(int));
+unsigned char *char_ptr =(unsigned char*)v;
+for(unsigned char i=0;i<n*4;i++){
+    printf("%p -> 0x%x\n", char_ptr, *(char_ptr+i));
+}
+}
+
+void print_short(int *v,int n){
+short *short_ptr =(short*)v;
+for(unsigned short i=0;i<n*2;i++){
+    printf("%p -> 0x%x\n", short_ptr, *(short_ptr+i));
+}
+}
+
+void print_int(int *v,int n){
+int *int_ptr =v;
+for(unsigned int i=0;i<n;i++){
+    printf("%p -> 0x%x\n", int_ptr, *(int_ptr+i));
+}
+}
+
+
+int main() {
+    int v[] = {0xCAFEBABE, 0xDEADBEEF, 0x0B00B135, 0xBAADF00D, 0xDEADC0DE};
+printf("MARIME V: %ld, ELEMENTE V: %ld \n", sizeof(v), sizeof(v)/sizeof(int));
+printf("PENTRU CHAR \n");
+ print_char(v,5);
+ printf("PENTRU short \n");
+ print_short(v,5);
+ printf("PENTRU INT \n");
+ print_int(v,5);
+    (void) v;
+
+    return 0;
+}

laborator/content/operatii-memorie-gdb/2-delete-first/Makefile

@@ -0,0 +1,2 @@
+PROGNAME := delete-first
+include ../../utils/Makefile.generic

laborator/content/operatii-memorie-gdb/2-delete-first/delete-first.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+char* delete_first(char *s, char *pattern)
+{
+	int found_it = strstr(s,pattern) - s;
+	char *s2 = strcpy(s + found_it, s + found_it + strlen(pattern));
+	memcpy(s + found_it, s2, strlen(s2) );
+	return s;
+}
+
+int main(){
+	char s[] = "Ana are mere";
+	char *pattern = "re";
+
+	 printf("%s\n", delete_first(s, pattern));
+
+	return 0;
+}

laborator/content/operatii-memorie-gdb/3-pixels/Makefile

@@ -0,0 +1,2 @@
+PROGNAME := pixels
+include ../../utils/Makefile.generic

laborator/content/operatii-memorie-gdb/ex3/pixel.h → laborator/content/operatii-memorie-gdb/3-pixels/pixel.h

@@ -8,9 +8,9 @@ typedef struct Pixel {
 } Pixel;
 
 typedef struct Picture {
-	int height;    
-	int width;        
-	Pixel **pix_array; 
+	int height;
+	int width;
+	Pixel **pix_array;
 } Picture;
 
 Picture* generatePicture(int height, int width, Pixel **pix_array) {
@@ -28,7 +28,7 @@ Picture* generatePicture(int height, int width, Pixel **pix_array) {
 			pic->pix_array[i][j] = pix_array[i][j];
 		}
 	}
-    
+
 	return pic;
 }
 
@@ -74,7 +74,9 @@ Pixel** generatePixelArray(int height, int width) {
 }
 
 void freePixelArray(Pixel ***pix_array, int height, int width) {
-	for (int i = 0 ; i < height ; ++i) 
+	(void) width;
+
+	for (int i = 0 ; i < height ; ++i)
 		free((*pix_array)[i]);
 
 	free(*pix_array);

laborator/content/operatii-memorie-gdb/3-pixels/pixels.c

@@ -0,0 +1,74 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <time.h>
+#include "pixel.h"
+#define GET_PIXEL(a,i,j) (*(*(a+i)+j))
+
+/*
+	TODO a
+	Functia primeste ca parametru o imagine si intoarce imaginea rasturnata.
+	Prin imagine rasturnata se intelege inversarea liniilor matricei pix_array
+	din structura lui Picture, astfel: Linia 1 devine linia n, linia 2 devine
+	linia n - 1, etc.
+*/
+// void swap(){
+// pic->GET_PIXEL(pix_array,i,j).R = 0.3 * pic->GET_PIXEL(pix_array,i,j).R;
+// 	pic->GET_PIXEL(pix_array,i,j).G = 0.59 * pic->GET_PIXEL(pix_array,i,j).G;
+// 	pic->GET_PIXEL(pix_array,i,j).B = 0.11 * pic->GET_PIXEL(pix_array,i,j).B;
+// // }
+
+void reversePic(Picture *pic){
+
+	for(int i=0;i<pic->height/2;i++){
+		for (int j=0;j<pic->width;j++){
+			unsigned char aux;
+	aux=pic->pix_array[pic->height-i-1][j].R;
+	pic->pix_array[pic->height-i-1][j].R=pic->pix_array[i][j].R;
+	pic->pix_array[i][j].R =aux;
+
+	aux=pic->pix_array[pic->height-i-1][j].G;
+	pic->pix_array[pic->height-i-1][j].G=pic->pix_array[i][j].G;
+	pic->pix_array[i][j].G =aux;
+
+	aux=pic->pix_array[pic->height-i-1][j].B;
+	pic->pix_array[pic->height-i-1][j].B=pic->pix_array[i][j].B;
+	pic->pix_array[i][j].B =aux;
+
+		}
+	}
+
+
+}
+
+void colorToGray(Picture *pic){
+
+	for(int i=0;i<pic->height;i++){
+		for (int j=0;j<pic->width;j++){
+	pic->pix_array[i][j].R = 0.3 * pic->pix_array[i][j].R;
+	pic->pix_array[i][j].G = 0.59 * pic->pix_array[i][j].G;
+	pic->pix_array[i][j].B = 0.11 * pic->pix_array[i][j].B;
+		}
+	}
+
+
+}
+
+
+int main() {
+	int height, width;
+	scanf("%d%d", &height, &width);
+	Pixel **pix_array = generatePixelArray(height, width);
+	Picture *pic = generatePicture(height, width, pix_array);
+	printf("poza inainte: \n");
+	printPicture(pic);
+	printf("poza dupa: \n");
+	reversePic(pic);
+	printPicture(pic);
+
+	freePicture(&pic);
+	freePixelArray(&pix_array, height, width);
+
+	return 0;
+}

laborator/content/operatii-memorie-gdb/4-find-max/Makefile

@@ -0,0 +1,2 @@
+PROGNAME := find-max
+include ../../utils/Makefile.generic

laborator/content/operatii-memorie-gdb/4-find-max/find-max.c

@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+
+
+void *find_max(void *arr, int n, int element_size,
+				int (*compare)(const void *, const void *)) {
+	void *max_elem = arr;
+	for(int i=0;i<n;i++){
+		if(compare(arr+i*4,max_elem))
+		// printf("element : %d", *(int*)(arr+i*4));
+		max_elem=arr+i*4;
+	}
+
+	(void) n;
+	(void) element_size;
+	(void) compare;
+
+	return max_elem;
+}
+
+
+int compare_ints(const void *a, const void *b){
+	// int* inta=(int *)a;
+	// int* intb=(int *)b;
+	for(int i=0;i<sizeof(int);i++){
+		if(*(int*)(a+i)>*(int*)(b+i))
+		return 1;
+		if(*(int*)(a+i)>*(int*)(b+i))
+		return 0;
+	}
+	return 0;
+
+}
+
+
+int main() {
+	int n;
+	scanf("%d", &n);
+
+	int *arr = malloc(n * sizeof(*arr));
+
+	for (int i = 0 ; i < n; ++i)
+		scanf("%d", &arr[i]);
+
+	int *res=(int *)find_max(arr,n,sizeof(*arr)/sizeof(int), compare_ints);
+	printf("%d" , *res);
+
+	free(arr);
+	return 0;
+}

laborator/content/operatii-memorie-gdb/5-segfault/Makefile

@@ -0,0 +1,3 @@
+PROGNAME := segfault
+include ../../utils/Makefile.generic
+

laborator/content/operatii-memorie-gdb/ex5/ex5.c → laborator/content/operatii-memorie-gdb/5-segfault/segfault.c

@@ -25,7 +25,7 @@ int main() {
 	for (int i = 0 ; i < n; ++i)
 		v[i] = nth_fibo(i);
 
-	v[423433] = 3;
+	// v[423433] = 3;
 	free(v);
 
 	return 0;