inicial

includes/meu_malloc.h

+#ifndef __MEU_MALLOC__
+#define __MEU_MALLOC__
+
+void iniciaAlocador();
+
+void finalizaAlocador();
+
+void aloca_espaco(int tam_alloc);
+
+void* alocaMem(int tam_alloc);
+
+//void arruma_heap();
+
+//void liberaMem(void* bloco);
+
+void print_mapa();
+
+#endif

makefile

+###########COMPILADORES##############
+GCC = gcc
+AR = ar
+AS = as
+
+#########DIRETORIOS CRIADOS###########
+INC=./includes
+SRC=./src
+BIN=./bin
+LIB=./lib
+
+LIBFLAGS=-lmeu_malloc -L$(LIB)
+INCFLAGS=-I$(INC)
+CFLAGS=-Wall -g -no-pie -fno-pie 
+ARFLAGS=rcs
+
+
+#LIGACOES
+build: diretorios libmeu_malloc.a
+	$(GCC) $(CFLAGS) $(INCFLAGS) $(SRC)/teste.c -o teste $(LIBFLAGS)
+
+libmeu_malloc.a: meu_malloc.o
+	$(AR) $(ARFLAGS) $(LIB)/libmeu_malloc.a $(BIN)/meu_malloc.o
+
+meu_malloc.o:
+	$(AS) $(SRC)/meu_malloc.s -o $(BIN)/meu_malloc.o -g 
+
+diretorios:
+	@echo "Criando Diretorios \n"
+	
+	@if [ ! -d "$(BIN)" ]; then \
+		mkdir $(BIN); \
+	fi
+	
+	@if [ ! -d "$(LIB)" ]; then \
+		mkdir $(LIB); \
+	fi
+
+clean:
+	@echo "Limpando Diretorios\n"
+	
+	@if [ -d "$(BIN)" ]; then \
+		rm -r $(BIN); \
+	fi
+	
+	@if [ -d "$(LIB)" ]; then \
+		rm -r $(LIB); \
+	fi

pseudoc.c

+/*ESSE ARQUIVO CONTEM UM PSEUDO CODIGO EM C, NAO TENTE COMPILAR ELE
+  NAO IRA FUNCIONAR, O PROGRAMA FUNCIONAL SE CHAMA meu_malloc.s 
+  ESSE ARQUIVO E APENAS UM MOLDE PARA O SEU SEMELHANTE EM ASSEMBLY
+*/
+
+short int livre = 1
+short int ocupado = 0
+void* piso_heap = 0
+void* teto_heap = 0;
+int alocador = 1040
+void* endr;
+
+//inicializa a heap utilizando a brk
+void iniciaAlocador()
+{	
+	endr = sbrk(0)		//endr na posicao corrente da heap
+	piso_heap = endr;	
+	endr += alocador;	//soma 1024 a posicao de endr
+	teto_heap = endr;	
+	brk(endr);			//aloca endr.
+	endr = piso_heap;
+	(endr) = 1;
+	8(endr) = alocador - 16;
+	
+	return;
+}
+
+void finalizaAlocador()
+{
+	//se existe o piso da heap	
+	if (piso_heap)
+	{
+		//retorno brk para o inicio da heap		
+		brk(piso_heap)
+		//coloca os paramentros novamente em 0 (necessario?)		
+		teto_heap = 0;	
+		piso_heap = 0;	
+	}	
+	
+	return;
+}
+
+void aloca_espaco(void tam_alloc)
+{
+	teto_heap += tam_alloc;
+	brk(teto_heap);
+	
+	return;
+}
+
+void* alocaMem(int tam_alloc)
+{
+	if(piso_heap == 0)
+		iniciaAlocador();
+	
+	endr = piso_heap;
+
+	while (endr <= teto_heap)
+	{
+		//endereco livre		
+		if((endr == LIVRE))
+		{
+			if (8(endr) >= tam_alloc)
+			{			
+				//8(endr) = valor contido dentro desse espaço de memoria				
+				8(endr) -= tam_alloc + 16;
+				endr += 8(endr) + 16;
+				(endr) = 0;
+				8(endr) = tam_alloc;		
+			}
+			else
+			{
+				if (endr == teto_heap)
+				{				
+					aloca_espaco(tam_alloc);
+					(endr) = 0;
+					8(endr) = tam_alloc;	
+				}			
+			}			
+			break;		
+		}		
+		//endereco ocupado		
+		endr += 8(endr) + 16
+	}	
+	
+	return (endr + 16);
+}
+
+
+
+		cmpq $LIVRE, %rbx
+		jne fim_if_aloca_mem
+	
+
+
+void arruma_heap()
+{
+	if (piso_heap == 1)
+		return;
+
+	endr_ant = piso_heap;
+	endr = piso_heap + 8(endr_ant) + 16;
+	while (endr < teto_heap)
+	{
+		if ((endr == 1) && (endr_ant == 1))
+			8(endr_ant) += 8(endr) + 16;
+		else
+			endr_ant = endr;
+
+		endr += 8(endr) + 16;
+	}
+
+	return;
+}
+
+void liberaMem(*void bloco)
+{
+	//bloco livre	
+	-16(bloco) = 1;
+	arruma_heap();	
+
+	return;
+}
+
+//printa o conteudo da heap cabecalho(##), espaço alocado vazio(--), 
+//espaço alocado ocupado(**) 
+void print_mapa()
+{
+	int i;
+	void* endr;	
+	
+	if (piso_heap == 0)
+	{
+		printf("NAO EXISTE ESPACO ALOCADO!\n");	
+		return;	
+	}	
+	endr = piso_heap;
+	while (endr < teto_heap)	
+	{
+		//imprime o cabecalho		
+		for (i = 0; i < 16; i++)
+			printf("#");	
+		
+		//imprime o conteudo		
+		if ((endr == LIVRE))				
+			//livre			
+			for (i = 0; i < 8(endr); i++)
+				printf("-");
+		else	
+			//ocupado			
+			for (i = 0; i < 8(endr); i++)
+				printf("*");
+		
+		endr += 8(endr) + 16;			
+	}
+
+	return;
+}

src/meu_malloc.s

+.section .data                                        
+	piso_heap : .quad 0
+	teto_heap : .quad 0
+	str1: .string "NAO EXISTE ESPACO ALOCADO!\n"
+	str2: .string "#"
+	str3: .string "-"
+	str4: .string "*"
+	str5: .string "INICIANDO O ALOCADOR\n"
+	pula_Linha: .string "\n"
+
+	flag: .string "%d\n"		#############APAGARRRRRRRR########## 
+	oi: .string "oi\n"		#############APAGARRRRRRRR########## 
+
+.section .bss
+	.equ ALOCADOR, 1040
+	.equ LIVRE, 1
+	.equ OCUPADO, 0
+
+.section .text
+	.globl iniciaAlocador
+	.globl finalizaAlocador
+	.globl aloca_espaco
+	.globl alocaMem
+	.globl arruma_heap
+	.globl liberaMem
+	.globl print_mapa
+#---------------------------------------------------------------------#
+iniciaAlocador:
+	pushq %rbp
+	movq %rsp, %rbp
+	
+	movq $str5, %rdi
+	call printf
+
+	movq $0, %rdi			# sbrk(0)
+	movq $12,%rax
+	syscall
+	
+	movq %rax, piso_heap	#piso_heap = inicio_heap
+	addq $ALOCADOR, %rax
+	movq %rax, teto_heap	#teto_heap = piso + alocador
+	
+	movq %rax, %rdi			#aloca o espaco reservado
+	movq $12, %rax
+	syscall	
+	
+	movq piso_heap, %rax
+	movq $LIVRE, (%rax)		#deixa livre o primeiro slot de memoria
+	movq $ALOCADOR, %r12
+	subq $16, %r12
+	movq %r12, 8(%rax)		#disponibiliza o tamanho do espaco alocado
+	
+	popq %rbp
+	ret
+#---------------------------------------------------------------------#
+finalizaAlocador:
+	pushq %rbp
+	movq %rsp, %rbp
+
+	movq piso_heap, %rax
+	cmpq $0, %rax
+	je fim_if
+		movq %rax, %rdi		
+		movq $12, %rax		#coloca a posicao da heap de volta no começo
+		syscall
+
+		movq $0, teto_heap	#zera o topo e o piso da heap
+		movq $0, piso_heap
+		jmp fim_if
+	fim_if:
+	
+	popq %rbp
+	ret
+#---------------------------------------------------------------------#
+aloca_espaco:
+	pushq %rbp
+	movq %rsp, %rbp
+		#traducao nao feita
+
+	popq %rbp
+	ret
+#---------------------------------------------------------------------#
+alocaMem:
+	pushq %rbp
+	movq %rsp, %rbp
+	subq $8, %rsp		#aloca espaco para endr	
+	
+	movq %rdi, %r12		#r12 = ponteiro alocado
+	
+	#movq $flag, %rdi
+	#movq %r12, %rsi
+	#call printf	
+	
+	movq piso_heap, %rbx
+	cmpq $0, %rbx
+	jne fim_if_aloca_mem	
+		call iniciaAlocador		 
+	fim_if_aloca_mem:
+
+	movq %rbx,-8(%rbp)
+	movq -8(%rbp), %rbx			# endr = -8(rbp)
+	while_loop_aloca_mem:
+	cmpq teto_heap, %rbx			#rbx = endr
+	jg fim_while_aloca_mem
+		cmpq $LIVRE, (%rbx)
+		jne fim_if_while_aloca_mem
+			cmpq %r12, 8(%rbx)
+			jl else_if_aloca_mem2
+				addq $16, %r12		#8(endr) -= tam_alloc + 16
+				subq %r12, 8(%rbx)				
+				
+				addq $16, 8(%rbx)	#endr += 8(endr) + 16
+				addq 8(%rbx), %rbx
+			
+				movq $OCUPADO, (%rbx)
+				movq %r12, 8(%rbx)
+				
+			jmp fim_if_aloca_mem2
+			else_if_aloca_mem2:					
+				cmpq teto_heap, %rbx
+				jne fim_if_aloca_mem2
+					pushq %r12					
+					call aloca_espaco
+					movq $OCUPADO,(%rbx)
+					movq %r12, 8(%rbx)										
+				jmp fim_if_aloca_mem2
+			fim_if_aloca_mem2:
+			jmp fim_while_aloca_mem	
+		
+		fim_if_while_aloca_mem:
+		addq $16, 8(%rbx)
+		movq 8(%rbx), %r10
+		addq %r10, %rbx		
+		jmp while_loop
+	fim_while_aloca_mem:	
+			
+	movq %rbx, %rax		#retorna endr + 16
+	addq $16, %rax	
+	
+	addq $8, %rsp
+	popq %rbp
+	ret
+#---------------------------------------------------------------------#
+arruma_heap:
+	pushq %rbp
+	movq %rsp, %rbp
+		#traducao nao feita	
+	popq %rbp
+	ret
+#---------------------------------------------------------------------#
+liberaMem:
+	pushq %rbp
+	movq %rsp, %rbp
+		#traducao nao feita
+	popq %rbp
+	ret
+#---------------------------------------------------------------------#
+print_mapa:
+	pushq %rbp
+	movq %rsp, %rbp
+	subq $16, %rsp		#coloca i na pilha
+
+	movq piso_heap, %rbx
+	cmpq $0, %rbx
+	jne fim_if_mapa	
+		movq $str1, %rdi
+		call printf
+		addq $16, %rsp
+		popq %rbp
+		ret		 
+	fim_if_mapa:
+	movq %rbx,-16(%rbp)
+	movq -16(%rbp), %rbx			# endr = -8(rbp)
+	while_loop:
+	cmpq teto_heap, %rbx
+	jge fim_while_loop		
+		movq $0, -8(%rbp)		#i = 0
+		movq -8(%rbp), %r12		#r12 = i
+		for_cabecalho:
+		cmpq $16, %r12
+		jge fim_for_cabecalho
+			movq $str2, %rdi
+			call printf
+			addq $1, %r12
+			jmp for_cabecalho
+		fim_for_cabecalho:
+			#movq flag,%rdi		
+			#movq 8(%rbx),%rsi
+			#call printf		
+		
+		cmpq $LIVRE, (%rbx)
+		jne else_if_while
+			movq $0, -8(%rbp)		#i = 0
+			movq -8(%rbp), %r12		#r12 = i
+			for_livre:
+			cmpq 8(%rbx), %r12
+			jge fim_for_livre
+				movq $str3, %rdi
+				call printf
+				addq $1, %r12
+				jmp for_livre
+			fim_for_livre:
+			jmp fim_if_while
+
+		else_if_while:
+			movq $0, -8(%rbp)		#i = 0
+			movq -8(%rbp), %r12		#r12 = i
+			for_ocupado:
+			cmpq 8(%rbx), %r12
+			jge fim_for_ocupado
+				movq $str4, %rdi
+				call printf
+				addq $1, %r12
+				jmp for_ocupado
+			fim_for_ocupado:
+			jmp fim_if_while
+		
+		fim_if_while:
+		addq $16, 8(%rbx)
+		addq 8(%rbx), %rbx
+		jmp while_loop
+	
+	fim_while_loop:
+	
+	movq $pula_Linha, %rdi
+	call printf
+
+	addq $16, %rsp
+	popq %rbp
+	ret
+#---------------------------------------------------------------------#

src/teste.c

+#include <meu_malloc.h>
+
+int main()
+{
+	void* x;
+	
+	iniciaAlocador();
+	x = alocaMem(1024);
+	print_mapa();
+	finalizaAlocador();
+	
+	return (0);
+}