[SOLUCIONADO] [Gnu AS] BruteForce

#include <stdio.h>

int fuerzabruta(char *S, char *s, int lS, int ls)
{
        int i, j;

        for(i=0; i<lS-ls+1; i++)
                if(S[i]==s[0]) {
                      for (j=0; j<ls; j++){
                              if (S[i+j] != s[j]) break;
                      }
    
                        if(j==ls) return i;
        }
        return -1; 
}   

#int fuerzabruta(char *S, char *s, int lS, int ls){
#	int i, j;
#	for(i=0; i<lS-ls+1; i++)
#		if(S[i]==s[0]) {
#			for(j=0; j<ls && S[i+j]==s[j]; j++);
#			if(j==ls) return i;
#	}
#	return -1;
#}

# Retorna la posición del primer elemento de la cadena a buscar.
# "sHolasos" "sos" retorna 5.



# lS = %rdx
# ls = %rcx

.data
	i: .quad 0

.text
.global bf
bf:
	# iremos incrementando (df = 0)
	cld

	# Guardo variable ls en otro registro.
	# rdx = ls
	movq %rcx,%r8
	

	# cuantas veces repetimos al primer for?
	
	subq %rcx,%rdx	# rdx = rdx - rcx
			# es decir: lS = lS - ls

	addq $1,%rdx # sumo 1 



	# Lo cargamos al rcx para el bucle.
	movq %rdx, %rcx
aca:
	lodsb # copiamos el primer caracter de la 2da cadena en el rax
#	decq %rsi

	sigue1:
		#lodsb
		# primero busco el primer caracter de la cadena 2 en la cadena 1.
		# mas tecnico: comparamos rax con rdi
		scasb
		# si encontramos el primer caracter en algun lugar de la cadena, saltamos al 2do for.
		
		je found
	loop sigue1
	# termina.
	# -1 si no lo encontramos el primer caracter de la 2da cadena en la primera.
	movq $-1, %rax
	ret


found:
	# encontramos el primer caracter de la 2da cadena en la primera.
	# estamos dentro del primer if.
	# usaremos el registro r8, hasta el momento r8 = ls.

	# Quiero saber el valor de i
	# i = %rdx - %rcx
	# i = lS-ls+1 - veces repetido (hacia atras,es decir del tope al 0).

	# Guardamos informacion del bucle anterior.
	movq %rcx,%r13
	movq %rdx,%r15
	movq %rsi,%r9
	subq $1,%r9

	subq %rcx,%rdx # rdx = rdx - rcx ( i = rdx )


	# Cargamos r8=ls a rcx para el 2do for. Hay que restar uno.
	movq %r8,%rcx
	decq %rcx
	movq %rdi,%r14
	sigue2:
		# comprobamos si los siguientes caracteres estan en la cadena 1.
		# tengo que cambiar adonde apunta rdi, es decir la primer cadena. ( S[i+j] ) 
		# i = rdx
		cmpsb
		jne fail
	loop sigue2
	movq %rdx,%rax
	addq $1,%rax
	ret
		
	
# fallo en el 2do for.
fail:
	# el último if ( if j == ls return i )
	# si es igual a 0 significa que recorrió todo el bucle.
	cmpq $0, %rcx
	je final
	# si no son iguales vuelvo al 1do for.

	# antes cargo el rcx y rdi de nuevo, con informacion del i del primer bucle.
	# restauro registros
	movq %r13,%rcx
	movq %r14,%rdi

	movq %r9, %rsi
	movq %r15,%rdx
	jmp aca

final:
	subq %rcx,%rdx # es el i
	movq %rdx,%rax
	ret

.text
.global bf
bf:
	cld
	movq %rcx,%r8
	
	subq %rdx,%rcx	# rdx = rdx - rcx
			# lS = lS - ls
	addq $1, %rdx

	movq %rdx,%r9

	movq %rdx,%rcx
	aca:
		lodsb # cargamos el primer caracter de la 2da cadena en el rax.		
		subq $1,%rsi

		_1for:
			scasb
			je si_eq_s0
		loop _1for
		movq $-1, %rax
		ret

si_eq_s0:
	# Para volver al anterior bucle.
	movq %rsi, %r14
	addq $1,%rsi
	movq %rdi, %r12
	movq %rcx, %r13 # valor de i.

	subq %r13,%r9 # valor de i


	movq %r8,%rcx
	subq $1,%rcx

	_2for:
		cmpsb # rsi == rdi?
		jne fail
	loop _2for
	movq %r13,%rax
	ret
	
fail:
	cmpq $0,%rcx
	je final
	
	movq %r14,%rsi
	movq %r12,%rdi
	movq %r13,%rcx
	jmp aca

final:
	movq %r9,%rax
	ret

#include <stdio.h>
int bf ( char *s1, char *s2, int long_s1, int long_s2);
int main (void){
	printf ("Resultado: %d\n",bf("soAdSDsos","sos",9,3));
        return 0;
}

subq %rcx,%rdx  # rdx = rdx - rcx
                        # es decir: lS = lS - ls

subq %rdx,%rcx  # rdx = rdx - rcx
                        # lS = lS - ls

.text
.global bf
bf:
	cld
	movq %rcx,%r8
	
	subq %rcx,%rdx
	incq %rdx

	movq %rdx,%rcx

	aca:
		lodsb
		_1for:
			scasb
			je Si_eq_s0
		loop _1for

		movq $-1,%rax
		ret

Si_eq_s0:
	movq %rcx,%r13
	movq %rsi,%r11
	movq %rdi,%r12

	# comprobamos denuevo letra anterior porque sino queda vacio y da true.
	incq %rcx
	decq %rsi
	decq %rdi

	subq %rcx,%rdx	# este es la posición.

	# esta bucle se repite ls-1 veces.
	movq %r8,%rcx # r8=ls
	decq %rcx
	decq %rcx
	
	_2for:
		cmpsb
		jne fail
	loop _2for
	movq %rdx,%rax
	ret

fail:
	movq $1337,%rax
	ret

.text
.global bf
bf:
	cld
	movq %rcx,%r8
	
	subq %rcx,%rdx
	incq %rdx

	movq %rdx,%rcx

	aca:
		lodsb
		_1for:
			scasb
			je Si_eq_s0
		loop _1for

		movq $-1,%rax
		ret

Si_eq_s0:
	movq %rcx,%r13
	movq %rsi,%r11
	decq %r11 # siempre apunta al primero
	movq %rdi,%r12

	# comprobamos denuevo letra anterior porque sino queda vacio y da true.
#	incq %rcx # VER
	decq %rsi
	decq %rdi

	subq %rcx,%rdx	# este es la posición.

	# esta bucle se repite ls-1 veces.
	movq %r8,%rcx # r8=ls
	decq %rcx
	
	_2for:
		repe cmpsb
		jne fail
	
	jmp final

fail:
	cmpq $0,%rcx
	je final

	movq %r13,%rcx
	movq %r11,%rsi
	movq %r12,%rdi
	jmp aca

final:
	subq %rcx,%rdx
	movq %rdx,%rax	
	ret

.text
.global bf
bf:
	cld
	movq %rcx,%r8
	subq %rcx,%rdx
	incq %rdx

	movq %rdx,%rcx
	aca:
		lodsb
		_1for:
			scasb #repne
			je Si_eq_s0
		loop _1for

		movq $-1,%rax
		ret

Si_eq_s0:
	# el valor de i:
	movq %rdx,%r9
	subq %rcx,%rdx	

	movq %rdx,%r15
	movq %rcx,%r13
	decq %r13
	movq %rsi,%r11
	decq %r11 # siempre apunta al primero
	movq %rdi,%r12

	# comprobamos denuevo letra anterior porque sino queda vacio y da true.
	# incq %rcx # VER
	decq %rsi
	decq %rdi

	subq %rcx,%rdx	# este es la posición.

	# esta bucle se repite ls-1 veces.
	movq %r8,%rcx # r8=ls
	
	
	_2for:
		cmpsb
		jne fail
	loop _2for

	movq %r15,%rax
	ret

fail:
	movq %r13,%rcx
	movq %r11,%rsi
	movq %r12,%rdi
	movq %r9,%rdx
	jmp aca