Unsigned Int Multiplication in C - c

Question

So I am trying to implement this algorithm in C for multiplying 32-bit unsigned int in order to understand it better:
Step 1: Test multiplier-0
Step 2: if 1, add multiplicand to left half of product
and place the result in the left half of
the product register
Step 3: shift multiplier right 1 bit
Step 4: shift product register right 1 bit
What I am not getting is how to implement step 2. It says to add multiplicand to left half of product and store in left half of product register. I am confused on how to add only to the left half of the product. How do I go about this?
EDIT:
This is something I came with but it does not give me the right answer and I am not sure what is going wrong. Please help!
long unsigned UnsignedMult(unsigned multiplicand, unsigned multiplier){
unsigned int temp32a, temp32b;
unsigned long temp64;
unsigned long product;
int i;
product = multiplier;
temp32b = multiplicand;
for(i=0; i < 32; i++){
if((product & 1)==1){ //add
temp64 = product;
temp64 = temp64 >> 32;
temp32a = temp64;
product = BinaryAdd(temp32a, temp32b);
}
product = product >>= 1;
}
return product;
}
int BinaryAdd(int in1, int in2){
int sum, carry;
sum = in1 ^ in2; // x XOR y
carry = in1 & in2; // x AND y carry in
int i;
for (i = 0; i < 32; i++) {
carry = carry << 1;
in1 = sum;
in2 = carry;
sum = in1 ^ in2; //calculate sum
carry = in1 & in2; //find carry out
}
return sum;
}

Answer 1

Your product register needs to be 64 bits in length to allow two 32 bit integers to be multiplied. Hopefully you have uint64_t available in your compiler to represent this (stdint.h).
To do the addition, you could put your multiplicand into a 64 bit integer, shift it left 32 bits, and then add it to the 64 bit product register.
Something like:
uint64_t tmpMulti;
uint64_t productRegister = 0;
uint32_t multiplicand = 123;
tmpMulti = multiplicand;
tmpMulti <<= 32;
productRegister += tmpMulti;
(Apologies for any syntax mistakes, I haven't written C code in a long time)
Out of interest, I had a go at implementing it myself. This seems to work:
#include <stdio.h>
#include <stdint.h>
void main(int argc, char* argv[])
{
uint32_t multiplier = 17;
uint32_t multiplicand = 12;
uint64_t productRegister = multiplier;
for (int n = 0; n < 32; n++) {
if (productRegister & 1 == 1) {
productRegister += ((uint64_t)multiplicand) << 32;
}
productRegister >>= 1;
}
printf("Result: %d\n", productRegister);
}
The following code does not use <stdint.h>, and uses two 32 bit ints to represent the 64 bit product register. It doesn't attempt to handle overflow, and assumes the answer will fit in 32 bits.
#include <stdio.h>
void main(int argc, char* argv[])
{
unsigned int multiplier = 17;
unsigned int multiplicand = 12;
unsigned int productRegisterLower = multiplier;
unsigned int productRegisterUpper = 0;
for (int n = 0; n < 32; n++) {
if (productRegisterLower & 1 == 1) {
productRegisterUpper += multiplicand;
}
productRegisterLower >>= 1;
productRegisterLower |= productRegisterUpper << 31;
productRegisterUpper >>= 1;
}
printf("Result: %d\n", productRegisterLower);
}
In order to handle the right shift of the product register, it moves the least significant bit of the upper half into the most significant bit of the lower half. To do this, it:
Shifts the lower half to the right 1 bit.
Takes a copy of the upper half and shifts it left 31 bits, so that the least significant bit is now on the left, and the rest of the value is zero.
ORs this with the lower half, to copy the shifted bit across.
Shifts the upper half to the right 1 bit.