(aes_encrypt): Added comments.

Rev: src/nettle/sparc/aes.asm:1.7

sparc/aes.asm

@@ -66,44 +66,28 @@ key_addition_8to32:
 	.type	key_addition32,#function
 	.proc	020
 key_addition32:
-	! Use %g2 and %g3 as temporaries, %o3 as counter
-	mov	-4, %o3
-	! Increment txt
-	add	%o0, 4, %o0
-.LL26:
-	! Get txt[i]
-	ld	[%o0+%o3], %g2
-	add	%o3, 4, %o3
-	! Get keys[i]
-	ld	[%o1+%o3], %g3
-	cmp	%o3, 12
+	! Unrolled version
+	ld	[%o0], %g2
+	ld	[%o1], %g3
+	xor	%g2, %g3, %g3
+	st	%g3, [%o2]
 
+	ld	[%o0+4], %g2
+	ld	[%o1+4], %g3
 	xor	%g2, %g3, %g3
+	st	%g3, [%o2+4]
 
-	bleu	.LL26
-	st	%g3, [%o2+%o3]
-	
-	retl
-	nop
+	ld	[%o0+8], %g2
+	ld	[%o1+8], %g3
+	xor	%g2, %g3, %g3
+	st	%g3, [%o2+8]
 
+	ld	[%o0+12], %g2
+	ld	[%o1+12], %g3
+	xor	%g2, %g3, %g3
+	retl
+	st	%g3, [%o2+12]
 
-! 	
-! 	mov	%o0, %o4
-! 	mov	0, %o3
-! .LL26:
-! 	sll	%o3, 2, %g2
-! 	ld	[%o1+%g2], %g3
-! 	add	%o3, 1, %o3
-! 	ld	[%o4+%g2], %o0
-! 	cmp	%o3, 3
-! 
-! 	xor	%g3, %o0, %g3
-! 
-! 	bleu	.LL26
-! 	st	%g3, [%o2+%g2]
-! 
-! 	retl
-! 	nop
 
 .LLfe2:
 	.size	key_addition32,.LLfe2-key_addition32
@@ -176,155 +160,280 @@ idx:
 	.global aes_encrypt
 	.type	aes_encrypt,#function
 	.proc	020
+
+! input parameters
+define(ctx,	%i0)
+define(length,	%i1)
+define(dst,	%i2)
+define(src,	%i3)
+
+! locals
+define(g_idx, %i5)
+	
+define(dtbl,	%l1)
+define(round,	%l3)
+define(txt,	%l5)
+define(wtxt,	%l6)
+
 aes_encrypt:
 	save	%sp, -136, %sp
 
-	andcc	%i1, 15, %g0
+	andcc	length, 15, %g0
 	bne	.Lencrypt_fail
-	cmp	%i1, 0
+	cmp	length, 0
 	be	.Lencrypt_end
 	sethi	%hi(idx), %i4
-	add	%fp, -24, %l6
-	add	%fp, -40, %l5
-	or	%i4, %lo(idx), %i5
+	add	%fp, -24, wtxt
+	add	%fp, -40, txt
+	or	%i4, %lo(idx), g_idx
 .Lencrypt_block:
-	mov	%i3, %o0
-	mov	%i0, %o1
+	! key_addition_8to32(src, ctx->keys, wtxt);
+	mov	src, %o0
+	mov	ctx, %o1
 	call	key_addition_8to32, 0
-	mov	%l6, %o2
-	ld	[%i0+480], %o0
-	mov	1, %l3
-	cmp	%l3, %o0
-	bgeu	.LL77
+	mov	wtxt, %o2
+
+	! get nrounds
+	ld	[ctx+480], %o0
+	mov	1, round
+	cmp	round, %o0
+	bgeu	.Lencrypt_final
 	sethi	%hi(64512), %o0
+
 	sethi	%hi(_aes_dtbl), %o0
-	or	%o0, %lo(_aes_dtbl), %l1
-	mov	%l5, %l4
-	mov	%l6, %l0
+	or	%o0, %lo(_aes_dtbl), dtbl
+
+	mov	txt, %l4
+	mov	wtxt, %l0
+	! FIXME:	%l7 = idx, seems redundant? 
 	or	%i4, %lo(idx), %l7
-	add	%i0, 16, %l2
-.LL53:
+	add	ctx, 16, %l2
+.Lencrypt_round:
+	! j:	%o7
+	! 4j:	%g2
 	mov	0, %o7
+	! %g3 = &idx[3][0]
 	add	%l7, 48, %g3
-.LL57:
+.Lencrypt_inner:
+	! %o0 = idx[3][0]
 	ld	[%g3], %o0
+	! %g2 = 4j
 	sll	%o7, 2, %g2
+	! %o1 = idx[2][0]
 	ld	[%g3-16], %o1
+	! %o2 = 4 idx[3][0]
 	sll	%o0, 2, %o0
+	! %o3 = wtxt[idx[3][0]], byte => bits 24-31
 	ldub	[%l0+%o0], %o3
 	sll	%o1, 2, %o1
+	! %o4 = wtxt[idx[2][0]], half-word???
 	lduh	[%l0+%o1], %o4
 	sll	%o3, 2, %o3
+	! %o0 = idx[1][0]
 	ld	[%g3-32], %o0
+	! %o4 = (wtxt[idx[2][0]] >> 16) & 0xff => bits 16-23
 	and	%o4, 255, %o4
-	ld	[%l1+%o3], %o2
+	! %o2 = dtbl[wtxt[idx[3][0]] >> 24]
+	ld	[dtbl+%o3], %o2
+	! %o0 = 4 idx[1][0]
 	sll	%o0, 2, %o0
+	! %o3 = dtbl[wtxt[idx[3][0]] >> 24] >> 24
 	srl	%o2, 24, %o3
+	! %o4 = 4 ((wtxt[idx[2][0]] >> 16) & 0xff)
 	sll	%o4, 2, %o4
+	! %o0 = &wtxt[idx[1][0]]
 	add	%l0, %o0, %o0
-	ld	[%l1+%o4], %o1
+	! %o1 = dtbl[(wtxt[idx[2][0]] >> 16) & 0xff]
+	ld	[dtbl+%o4], %o1
+	! %o2 = dtbl[wtxt[idx[3][0]] >> 24] << 8
 	sll	%o2, 8, %o2
+	! %o5 = (wtxt[idx[1][0]] >> 8) & 0xff
 	ldub	[%o0+2], %o5
+	! %o2 = ROL(dtbl[wtxt[idx[3][0]] >> 24])
 	or	%o2, %o3, %o2
+	! %o1 = dtbl[(wtxt[idx[2][0]] >> 16) & 0xff] 
+	!       ^ ROL(dtbl[wtxt[idx[3][0]] >> 24])  = XX1
 	xor	%o1, %o2, %o1
+	! %o3 = XX1 >> 24
 	srl	%o1, 24, %o3
+	! %o5 = 4 ((wtxt[idx[1][0]] >> 8) & 0xff)
 	sll	%o5, 2, %o5
+	! %o2 = wtxt[j]
 	ld	[%l0+%g2], %o2
+	! %o1 = XX1 << 8
 	sll	%o1, 8, %o1
-	ld	[%l1+%o5], %o0
+	! %o0 = dtbl[(wtxt[idx[1][0]] >> 8) & 0xff]
+	ld	[dtbl+%o5], %o0
+	! %o1 = ROL(XX1)
 	or	%o1, %o3, %o1
+	! %o0 = dtbl[(wtxt[idx[1][0]] >> 8) & 0xff] ^ ROL(XX1) = XX2
 	xor	%o0, %o1, %o0
+	! %o2 = wtxt[j] & 0xff
 	and	%o2, 255, %o2
+	! %03 = XX2 >> 24
 	srl	%o0, 24, %o3
+	! %o2 = 4 (wtxt[j] & 0xff)
 	sll	%o2, 2, %o2
-	ld	[%l1+%o2], %o1
+	! %o1 = dtbl[wtxt[j] & 0xff]
+	ld	[dtbl+%o2], %o1
+	! %o0 = XX2 << 8
 	sll	%o0, 8, %o0
+	! %o0 = ROL(XX2)
 	or	%o0, %o3, %o0
+	! %o1 = dtbl[wtxt[j] & 0xff] ^ ROL(XX2 = XX3
 	xor	%o1, %o0, %o1
+	! j++
 	add	%o7, 1, %o7
+	! txt[j] (old j) = XX3 
 	st	%o1, [%l4+%g2]
+	! j <= 3?
 	cmp	%o7, 3
-	bleu	.LL57
+	bleu	.Lencrypt_inner
+	! %g3 = &idx[3][j]
 	add	%g3, 4, %g3
+
+	! key_addition32(txt, ctx + 16, wtxt)
 	mov	%l2, %o1
-	mov	%l5, %o0
+	mov	txt, %o0
 	call	key_addition32, 0
-	mov	%l6, %o2
-	ld	[%i0+480], %o0
-	add	%l3, 1, %l3
-	cmp	%l3, %o0
-	blu	.LL53
+	mov	wtxt, %o2
+
+	! %o0 = nrounds
+	! FIXME:	Keep in some register?
+	ld	[ctx+480], %o0
+	add	round, 1, round
+	cmp	round, %o0
+	! round < nrounds?
+	blu	.Lencrypt_round
+	! %l2 = ctx->keys + r*4 
 	add	%l2, 16, %l2
+	
 	sethi	%hi(64512), %o0
-.LL77:
+.Lencrypt_final:
+	! %l3 = 0xff00 ???
 	or	%o0, 768, %l3
+	! %o7 = j = 0
 	mov	0, %o7
-	mov	%l6, %g3
+	! %g3 = wtxt
+	mov	wtxt, %g3
+	! %l2 = 0xff0000
 	sethi	%hi(16711680), %l2
+	! %l1 = 0xff000000
 	sethi	%hi(-16777216), %l1
-	mov	%l5, %l0
-	add	%i5, 48, %g2
+	! %l0 = txt 
+	mov	txt, %l0
+	! %g2 = &idx[3][0]
+	add	g_idx, 48, %g2
 .LL63:
+	! %o0 = idx[1][0]
 	ld	[%g2-32], %o0
+	! %o5 = 4 j
 	sll	%o7, 2, %o5
+	! %o2 = idx[2][0]
 	ld	[%g2-16], %o2
+	! %o0 = 4(idx[1][0])
 	sll	%o0, 2, %o0
+	! %o3 = wtxt[idx[1][0]]
 	ld	[%g3+%o0], %o3
+	! %o2 = 4 idx[2][0]
 	sll	%o2, 2, %o2
+	! %o4 = idx[3][0]
 	ld	[%g2], %o4
+	! %o3 = wtxt[idx[1][0]] & 0xff00 
 	and	%o3, %l3, %o3
+	! %o1 = wtxt[idx[2][0]]
 	ld	[%g3+%o2], %o1
+	! %o4 = 4 idx[3][0]
 	sll	%o4, 2, %o4
+	! %o0 = wtxt[idx[1][0]]
 	ld	[%g3+%o5], %o0
+	! %o1 = wtxt[idx[2][0]] & 0xff0000
 	and	%o1, %l2, %o1
+	! %o2 = wtxt[idx[3][0]]
 	ld	[%g3+%o4], %o2
+	! %o0 = wtxt[idx[1][0]] & 0xff
 	and	%o0, 255, %o0
+
+	! % o0 = wtxt[idx[1][0]] & 0xff
+	!        | wtxt[idx[1][0]] & 0xff00
+	!        | wtxt[idx[2][0]] & 0xff0000
 	or	%o0, %o3, %o0
 	or	%o0, %o1, %o0
+	! %o2 = wtxt[idx[3][0]] & 0xff000000
 	and	%o2, %l1, %o2
 	or	%o0, %o2, %o0
+	! j++
 	add	%o7, 1, %o7
+	! txt[j] = ... | ... | ... | ... (old j)
 	st	%o0, [%l0+%o5]
+	! j <= 3?
 	cmp	%o7, 3
 	bleu	.LL63
+	! %g2 = &idx[3][j]
 	add	%g2, 4, %g2
+	
 	sethi	%hi(_aes_sbox), %o0
 	or	%o0, %lo(_aes_sbox), %g3
+	
+	! %o7 = j = 0
 	mov	0, %o7
+	! %g2 = txt
 	mov	%l5, %g2
-.LL68:
+.Lencrypt_sbox:
+	! %o5 = 4 j
 	sll	%o7, 2, %o5
+	! %o3 = txt[j]
 	ld	[%g2+%o5], %o3
+	! j++
 	add	%o7, 1, %o7
+	! %o0 = (txt[j] >> 8) & 0xff (old j) 
 	srl	%o3, 8, %o0
 	and	%o0, 255, %o0
+	! %o4 = sbox[(txt[j] >> 8) & 0xff]
 	ldub	[%g3+%o0], %o4
+	! %o2 = (txt[j] >> 16) (old j)
 	srl	%o3, 16, %o2
+	! %o0 = txt[j] & 0xff
 	and	%o3, 255, %o0
+	! %o1 = sbox[txt[j] & 0xff]
 	ldub	[%g3+%o0], %o1
+	! %o2 = (txt[j] >> 16) & 0xff (old j)
 	and	%o2, 255, %o2
+	! %o0 = sbox[(txt[j] >> 16) & 0xff]
 	ldub	[%g3+%o2], %o0
+	! %o3 = txt[j] >> 24
 	srl	%o3, 24, %o3
+	! %o4 = sbox[txt[j] & 0xff] << 8
 	sll	%o4, 8, %o4
+	! %o2 = sbox[txt[j] >> 24]
 	ldub	[%g3+%o3], %o2
+	! %o1 = sbox[txt[j] & 0xff] 
+	!	| sbox[(txt[j] >> 8) & 0xff] << 8
 	or	%o1, %o4, %o1
+	!	| sbox[(txt[j] >> 16) & 0xff] << 16
 	sll	%o0, 16, %o0
 	or	%o1, %o0, %o1
+	!	| sbox[txt[j] >> 24] << 24
 	sll	%o2, 24, %o2
 	or	%o1, %o2, %o1
+	! j < 3 
 	cmp	%o7, 3
-	bleu	.LL68
+	bleu	.Lencrypt_sbox
+	! txt[j] = ... | ... | ... | ...
 	st	%o1, [%g2+%o5]
-	ld	[%i0+480], %o1
-	mov	%i2, %o2
+
+	! key_addition32to8(txt, ctx + nrounds * 4, dst,
+	ld	[ctx+480], %o1
+	mov	dst, %o2
 	sll	%o1, 4, %o1
-	add	%i0, %o1, %o1
+	add	ctx, %o1, %o1
 	call	key_addition32to8, 0
 	mov	%l5, %o0
-	add	%i3, 16, %i3
-	addcc	%i1, -16, %i1
+
+	add	src, 16, src
+	addcc	length, -16, length
 	bne	.Lencrypt_block
-	add	%i2, 16, %i2
+	add	dst, 16, dst
 	b,a	.Lencrypt_end
 .Lencrypt_fail:
 	sethi	%hi(.LLC0), %o0