CSAPP Lab1--Manipulating Bits

/*
* bitNor - ~(x|y) using only ~ and &
*   Example: bitNor(0x6, 0x5) = 0xFFFFFFF8
*   Legal ops: ~ &
*   Max ops: 8
*   Rating: 1
*/
int bitNor(int x, int y) {
return (~x)&(~y);
}

/*
* bitXor - x^y using only ~ and &
*   Example: bitXor(4, 5) = 1
*   Legal ops: ~ &
*   Max ops: 14
*   Rating: 2
*/
int bitXor(int x, int y) {

return (~(x&y)&~(~x&~y));

}
/*
* isNotEqual - return 0 if x == y, and 1 otherwise
*   Examples: isNotEqual(5,5) = 0, isNotEqual(4,5) = 1
*   Legal ops: ! ~ & ^ | + << >>
*   Max ops: 6
*   Rating: 2
*/
int isNotEqual(int x, int y) {

return (!!(x ^ y));
}
/*
* getByte - Extract byte n from word x
*   Bytes numbered from 0 (LSB) to 3 (MSB)
*   Examples: getByte(0x12345678,1) = 0x56
*   Legal ops: ! ~ & ^ | + << >>
*   Max ops: 6
*   Rating: 2
*/
int getByte(int x, int n) {
return (x>>(n<<3))&0xff;
}
/*
* copyLSB - set all bits of result to least significant bit of x
*   Example: copyLSB(5) = 0xFFFFFFFF, copyLSB(6) = 0x00000000
*   Legal ops: ! ~ & ^ | + << >>
*   Max ops: 5
*   Rating: 2
*/
int copyLSB(int x) {
return x<<31>>31;
}
/*
* logicalShift - shift x to the right by n, using a logical shift
*   Can assume that 1 <= n <= 31
*   Examples: logicalShift(0x87654321,4) = 0x08765432
*   Legal ops: ~ & ^ | + << >>
*   Max ops: 16
*   Rating: 3
*/
int logicalShift(int x, int n) {
return (x>>n)&(~((1<<31)>>n<<1));
}
/*
* bitCount - returns count of number of 1's in word
*   Examples: bitCount(5) = 2, bitCount(7) = 3
*   Legal ops: ! ~ & ^ | + << >>
*   Max ops: 40
*   Rating: 4
*/
int bitCount(int x) {

//for every 4 bits, save the number of 1's into itself .
//max number is 4 ,can be saved
int mask,sum;

mask=0x11|(0x11<<8);
mask=mask|(mask<<16);
sum=x&mask;

sum+=(x>>1)&mask;
sum+=(x>>2)&mask;
sum+=(x>>3)&mask;

//add high 16 bits into low 16 bits
//max number is 8,can be saved by 4 bits
mask=0xff|(0xff<<8);
sum=(sum>>16)+(sum&mask);

//for every 8 bits in low 16 bits,add high 4 bits into low 4 bits
//max number is 16 ,can't be saved .so let it saved by 8 bits
mask=0xf|(0xf<<8);
sum=((sum>>4)&mask)+(sum&mask);

//add high 8 bits into low 8 bits,
mask=0xff;
sum=(sum&mask)+(sum>>8);
return sum;
}
/*
* bang - Compute !x without using !
*   Examples: bang(3) = 0, bang(0) = 1
*   Legal ops: ~ & ^ | + << >>
*   Max ops: 12
*   Rating: 4
*/
int bang(int x) {
//notice the sign bit of +0 and -0 are both 0 ,but others are not.
int negx=~x+1;
int x_sign=(x>>31)&0x1;
int negx_sign=(negx>>31)&0x1;

return (x_sign|negx_sign)^0x1;
}
/*
* leastBitPos - return a mask that marks the position of the
*               least significant 1 bit. If x == 0, return 0
*   Example: leastBitPos(96) = 0x20
*   Legal ops: ! ~ & ^ | + << >>
*   Max ops: 6
*   Rating: 4
*/
int leastBitPos(int x) {
//x and -x have the same least significant bit
return x&(~x+1);
}
/*
* TMax - return maximum two's complement integer
*   Legal ops: ! ~ & ^ | + << >>
*   Max ops: 4
*   Rating: 1
*/
int tmax(void) {
return (1<<31>>31)^(1<<31);
}
/*
* isNonNegative - return 1 if x >= 0, return 0 otherwise
*   Example: isNonNegative(-1) = 0.  isNonNegative(0) = 1.
*   Legal ops: ! ~ & ^ | + << >>
*   Max ops: 6
*   Rating: 3
*/
int isNonNegative(int x) {
return ((x>>31)&0x1)^0x1;
}
/*
* isGreater - if x > y  then return 1, else return 0
*   Example: isGreater(4,5) = 0, isGreater(5,4) = 1
*   Legal ops: ! ~ & ^ | + << >>
*   Max ops: 24
*   Rating: 3
*/
int isGreater(int x, int y) {
//positive:0  , negtive: -1
int sign_x=x>>31;
int sign_y=y>>31;

//when sign is equal
int equal=(!(sign_x^sign_y))&((~y+x)>>31);
//when sign is not equal
int notEqual=sign_x&!sign_y;
return !(equal|notEqual);
}
/*
* divpwr2 - Compute x/(2^n), for 0 <= n <= 30
*  Round toward zero
*   Examples: divpwr2(15,1) = 7, divpwr2(-33,4) = -2
*   Legal ops: ! ~ & ^ | + << >>
*   Max ops: 15
*   Rating: 2
*/
int divpwr2(int x, int n) {
//mask = (2^n)-1
int mask = (1 << n) + ~0;
//positive: equalizer=0 ; negtive:  equalizer=(2^n)-1
int equalizer = (x >> 31) & mask;
//negtive need add (2^n)-1
return (x+equalizer)>>n;
}
/*
* abs - absolute value of x (except returns TMin for TMin)
*   Example: abs(-1) = 1.
*   Legal ops: ! ~ & ^ | + << >>
*   Max ops: 10
*   Rating: 4
*/
int abs(int x) {
//positive:0  , negtive: -1
int mask=x>>31;
//if x<0,res=~x ;else if x>=0, res=x;
int res=mask^x;
////if x<0,addition=1 ;else if x>=0, res=0;
int addition=(x>>31)&0x1;

return res+addition;
}
/*
* addOK - Determine if can compute x+y without overflow
*   Example: addOK(0x80000000,0x80000000) = 0,
*            addOK(0x80000000,0x70000000) = 1,
*   Legal ops: ! ~ & ^ | + << >>
*   Max ops: 20
*   Rating: 3
*/
int addOK(int x, int y) {
//calulate the sign of x,y and sum
int sum=x+y;
int signx=(x>>31)&0x1;
int signy=(y>>31)&0x1;
int signsum=(sum>>31)&0x1;

//overflow when signx=0 and signy=0 but signsum=1 ,
//overflow when signx=1 and signy=1 but signsum=0
int result=!!((signx^signy)+!(signx^signsum)+!(signy^signsum));
return result;
}