//-----------------------------------------------------------------
//	nicholas.s
//
//	Nicholas wrote: I was asked this question today at a job-
//	interview:
//
//	What is the fastest way to count the number of set bits in 
//	an array of ten-thousand 16-bit integers with an unlimited 
//	amount of RAM?
//
//	OK, here is one way we could attack this problem using x86
//	assembly language, taking advantage of the GNU assembler's 
//	repeat-macro capability (to reduce 'branching') and of the
//	processor's special 'xlat' instruction (permitting 'reuse' 
//	of our solutions for a small number of cases to be applied  
//	efficiently when we have a much larger number of cases).
//
//	programmer: ALLAN CRUSE
//	written on: 06 MAY 2008
//	revised on: 29 APR 2009 -- for our x86_64 Linux platforms
//-----------------------------------------------------------------


	.global	bit_total	# makes function-name visible

	# prototype: int bit_total( short *array, int count );
	# the 'array' argument will be passed in register RDI
	# the 'count' argument will be passed in register RSI
	# the function-value must be returned in register RAX


	.section	.data
lookup:	.zero	256		# this will be a lookup-table


	.section	.text
#
# This function will be called from a C++ program, with function
# arguments 'array' and 'count' passed in registers RDI and RSI; 
# it should return the array's total number of set bits in RAX.
#
bit_total:
	push	%rbx		# save caller's registers
	push	%rcx
	push	%rdx
	push	%rsi
	push	%rdi

	# construct a 'lookup-table' containing one entry
	# for each of the possible byte-values 0..255, so
	# that the i-th entry in this lookup-table equals
	# the number of set bits in that number i itself.
 	#
	# Algorithm for constructing the lookup-table:
	#
	#     for (int i = 0; i < 256; i++)
	#	for (int j = 0; j < 8; j++)
	#           if ( i & (1<<j) ) ++lookup[i];	
	#
	
	xor	%ebx, %ebx		# for array-index i
nxentry:	
	mov	%ebx, %eax		# copy of index i

	.rept	8			# once for each bit		
	shr	$1, %eax		# shift bit into CF
	adcb	$0, lookup(%rbx)	# add the bit-value  
	.endr				# end of repetition

	inc	%ebx			# advance index i
	cmp	$256, %ebx		# is i below 256?
	jb	nxentry			# yes, do another

	# now we can use this lookup-table to efficiently
	# total up the number of set bits in our array of 
	# ten-thousand 16-bit words, which we will regard
	# here as an array of twenty-thousand 8-bit bytes

	mov	%rsi, %rcx		# set RCX = 'count' 
	add	%rsi, %rcx		# double this count
	cld				# forward processing
	mov	%rdi, %rsi		# point RSI to array
	lea	lookup, %rbx		# point RBX to table
	xor	%rax, %rax		# clear bits in RAX

	xor	%rdx, %rdx		# initialize 'total'
nxbyte:	lodsb				# load next array-byte
	xlat				# lookup its bit-count
	add	%rax, %rdx		# add count to total
	loop	nxbyte			# again for next byte

	mov	%edx, %eax		# return total in RAX

	pop	%rdi			# recover saved registers
	pop	%rsi
	pop	%rdx
	pop	%rcx
	pop	%rbx	
	ret				# return to the caller

	.end