计算机系统基础 实验一 csapp date lab1
知识储备
首先需要明白基本的一些操作符所代表的含义
按位与(&)、按位或(|)、按位异或(^)、按位加(+)、逻辑取反(!)、按位取反(~)、左移(<<)、右移(>>)
按位与运算将两个运算分量的对应位按位遵照以下规则进行计算：
0 & 0 = 0, 0 & 1 = 0, 1 & 0 = 0, 1 & 1 = 1。
按位或运算将两个运算分量的对应位按位遵照以下规则进行计算：
0 | 0 = 0, 0 | 1 = 1, 1 | 0 = 1, 1 | 1 = 1
按位异或运算将两个运算分量的对应位按位遵照以下规则进行计算：
0 ^ 0 = 0, 0 ^1 = 1, 1 ^ 0 = 1, 1 ^ 1 = 0
按位加运算将两个运算分量的对应为按位遵照以下规则计算：
0 + 0 = 0，0 + 1 = 1，1 + 0 = 1，1 + 1 = 0
左移运算将一个位串信息向左移指定的位，右端空出的位用0补充，每左移1位相当于乘2
右移运算将一个位串信息向右移指定的位，右端移出的位的信息被丢弃，每右移1位，相当于除以2。对无符号数据，右移时，左端空出的位用0补充。对于带符号的数据，如果移位前符号位为0(正数)，则左端也是用0补充；如果移位前符号位为1(负数)，则左端用0或用1补充，取决于计算机系统。对于负数右移，称用0补充的系统为“逻辑右移”，用1补充的系统为“算术右移”。
按位取反为二进制串对应的1和0进行变换
逻辑取反只有0和非0两种情况
1.最低一位有效位置0
/*
* lsbZero - set 0 to the least significant bit of x
* Example: lsbZero(0x87654321) = 0x87654320
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 5
* Rating: 1
*/
int lsbZero(int x) {
//x右移一位再左移一位实现把最低一位有效位置0
x=x>>1;
x=x<<1;
return x;
}
2.x第n个字节实现取反
/*
* byteNot - bit-inversion to byte n from word x
* Bytes numbered from 0 (LSB) to 3 (MSB)
* Examples: getByteNot(0x12345678,1) = 0x1234A978
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 6
* Rating: 2
*/
int byteNot(int x, int n) {
int y=0xff;
n=n<<3;
y=y<<n;
x=x^y;
return x;
}
补充说明一道题：x怎么取第n个字节
/*
* 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 (x>>8*n)&0xff
*/
int getByte(int x, int n) {
return ((x>>(n<<3))&0xff);
}
题意解析：
对于0x12345678
当n=0时，return 0x78
当n=1时，return 0x56
当n=2时，return 0x34
当n=3时，return 0x12
解答过程与思考：
首先，在这个过程中，x应先右移8* n位再取最低的8位数值，
即 return (x>>8* n)&0xff
但是 不能用* 所以采用移位
return ((x>>(n<<3))&0xff);
3.比较x和y的第n个字节，如果相同，返回0，如果不相同，返回1
/*
* byteXor - compare the nth byte of x and y,
* if it is same, return 0, if not, return 1
* example: byteXor(0x12345678, 0x87654321, 1) = 1
* byteXor(0x12345678, 0x87344321, 2) = 0
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 20
* Rating: 2
*/
int byteXor(int x, int y, int n) {
n=n<<3;
x=(x>>n)&0xff;
y=(y>>n)&0xff;
return !!(x^y);
}
4.逻辑与
&&表示当两个操作数都是ture的时候，才返回true
/*
* logicalAnd - x && y
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 20
* Rating: 3
*/
int logicalAnd(int x, int y) {
x=!((!x)|(!y));
//x=(!(!x)&(!(!y);
return x;
}
设计思想：
1.把x和y分别取NOT，二者相或后再取NOT，即可得到逻辑与。
2.把x和y分别转换为逻辑的0和1，再相与。
5.逻辑或
|| 表示当两个操作数有一个为ture的时候，就返回true
/*
* logicalOr - x || y
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 20
* Rating: 3
*/
int logicalOr(int x, int y) {
x=(!(!x))|(!(!y));
return x;
}
把x和y分别转换为逻辑的0和1，再相或。
补充一道题：逻辑右移位（默认为算术右移位）
* logicalShift - shift x to the right by n, using a logical shift
* Can assume that 0 <= n <= 31
* Examples: logicalShift(0x87654321,4) = 0x08765432
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 20
* Rating: 3
*/
int logicalShift(int x, int n) {
int mask=~(((1<<31)>>n)<<1);
return (x>>n)&mask;
}
若x为正数或0，
0x0xxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx
return x>>n即可。
若x为负数，1xxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx
位运算时带符号整数 符号拓展前面将会补充1， 例如：
取（0x-87654321,4)
1000 7 6 5 4 3 2 1 右移4位，则1111 1000 7 6 5 4 3 2，后32-n位没问题
只需添加一个掩码，掩码把符号位转为0，若右移n位，则前n位应为0
1的原码为0000 0000 0000 0000 0000 0000 0000 0001
1<<31变成 1000 0000 0000 0000 0000 0000 0000 0000
右移(n-1)位，掩码为1111 0000 0000 0000 0000 0000 0000 0000
取反为 0000 1111 1111 1111 1111 1111 1111 1111
和x>>n进行与得到结果
由于可允许的运算符号 *Legal ops: ! ~ & ^ | + << >>*没有减号，所以将函数写成：
int logicalShift(int x, int n) {
int mask=~(((1<<31)>>n)<<1);
return (x>>n)&mask;
}
6.把x的前n位移到末尾
/*
* rotateLeft - Rotate x to the left by n
* Can assume that 0 <= n <= 31
* Examples: rotateLeft(0x87654321,4) = 0x76543218
* Legal ops: ~ & ^ | + << >> !
* Max ops: 25
* Rating: 3
*/
int rotateLeft(int x, int n) {
int y;
y=~((~0)<<n);
x=(x<<n)+((x>>(32+(~n+1)))&y);
return x;
}
设计思想：先构造y为高（32-n）位为0的y，再与x右移（32-n）的x相与，相当于储存了x的高n位数，最后再与x左移n位相加即可。
方法一 参照上一道补充题，右移32-n位，将函数写成
int rotateLeft(int x, int n) {
int mask=~(((1<<31)>>31)<<n);
return (((x>>32)<<n)&mask)+(x<<n);
}
报错，right shift count >= width of type，x>>32时右移计数>=类型的宽度
修改，x>>(32-n)，取n的补码，等于源码取反加一
x=(x<
方法二 想构造掩码为1111 1111 1111 1111 1111 1111 1111 0000，还可让 y=~(( ~0)<
int logicalShift(int x, int n) {
int mask=~((~0)<<(32+(~n+1)));
return (x>>n)&mask;
}
7.如果x的二进制包含奇数个1，则返回1
/*
* parityCheck - returns 1 if x contains an odd number of 1's
* Examples: parityCheck(5) = 0, parityCheck(7) = 1
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 20
* Rating: 4
*/
int parityCheck(int x) {
x=x^(x<<16);
x=x^(x<<8);
x=x^(x<<4);
x=x^(x<<2);
x=x^(x<<1);
x=x>>31;
return !(!x);
}
设计思想：将x的前16位与后16位进行按位异或……
每次移位将x的低半位数与高半位数进行异或，实现得到的x位表示总是减去偶数个1，并不影响x位表示中1个数的奇偶性。最后把得到的x右移31位，并变成逻辑1和0.
8.确定是否可以在不溢出的情况下计算2*x
/*
* mul2OK - Determine if can compute 2*x without overflow
* Examples: mul2OK(0x30000000) = 1
* mul2OK(0x40000000) = 0
*
* Legal ops: ~ & ^ | + << >>
* Max ops: 20
* Rating: 2
*/
int mul2OK(int x) {
return (((x>>31)&0x1)^((x>>30)&0x1))^0x1;
}
设计思想：计算2*x相当于逻辑左移一位，若x的符号位与第30位不同，则移位时符号位改变，溢出。
若x的符号位为1，则第30位为0时会溢出；若x符号位为0，则第30位为1时会溢出；于是将x的31位和30位分别与1相与，与1相与是本身，再异或，若相同异或为0，此时不溢出，由题意，再与1异或，使返回结果为1.
9.实现x*3/2向0舍入
/*
* mult3div2 - multiplies by 3/2 rounding toward 0,
* Should exactly duplicate effect of C expression (x*3/2),
* including overflow behavior.
* Examples: mult3div2(11) = 16
* mult3div2(-9) = -13
* mult3div2(1073741824) = -536870912(overflow)
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 12
* Rating: 2
*/
int mult3div2(int x) {
int t = (x << 1) + x; //t = 3*x
int LSB = t & 0x1; //取出最低位
int sign = (t >> 31) & 0x1; //取出符号位
int ans = (t >> 1); //ans = 3*x/2;
ans += (LSB & sign); //rounding toward 0;
return ans;
}
设计思想：左移一位为x* 2，再+x即x* 3。
10.确定是否可以在不溢出的情况下计算x-y
/*
* subOK - Determine if can compute x-y without overflow
* Example: subOK(0x80000000,0x80000000) = 1,
* subOK(0x80000000,0x70000000) = 0,
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 20
* Rating: 3
*/
int subOK(int x, int y) {
int z;
z=x+(~y+1);
z=(z>>31)&0x1;
x=(x>>31)&0x1;
y=(y>>31)&0x1;
return ((x^y)&(x^z))^0x1;
}
设计思想：x符号位与y符号位不同，且x符号位与（x-y）符号位也不同时，即溢出。
写法二：
int subOK(int x, int y) {
int ans = x + (~y + 1); //ans = x - y;
return !(((ans ^ x) & (x ^ y)) >> 31);
//当且仅当两个加数的符号位相同，而与他们的和的符号位不同，发生溢出
}
11.求x的绝对值
/*
* absVal - absolute value of x
* Example: absVal(-1) = 1.
* You may assume -TMax <= x <= TMax
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 10
* Rating: 4
*/
int absVal(int x) {
int y=x>>31;
x=(y&(~x+1))+((~y)&x);
return x;
}
设计思想：y = x>>31为x的符号位，当x符号位为0时，x绝对值就是x；当x符号位为1时，x绝对值是（~x+1）。
12.返回与f的绝对值相等的位级别
/*
* float_abs - Return bit-level equivalent of absolute value of f for
* floating point argument f.
* Both the argument and result are passed as unsigned int's, but
* they are to be interpreted as the bit-level representations of
* single-precision floating point values.
* When argument is NaN, return argument..
* Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
* Max ops: 10
* Rating: 2
*/
unsigned float_abs(unsigned uf) {
int x=uf&0x7fffffff;
if(x>0x7f800000)
return uf;//NaN
else
return x;
}
设计思想：
NaN（Not a Number，非数）表示未定义或不可表示的值。常在浮点数运算中使用。NaN 属性代表一个“不是数字”的值。这个特殊的值是因为运算不能执行而导致的，不能执行的原因要么是因为其中的运算对象之一非数字（例如， “abc” / 4），要么是因为运算的结果非数字（例如，除数为零）。
NaN表示的数阶码全为1，且小数域为非0。1111 1111 **** **** **** **** **** ***
解答过程与思考：
如果uf是NaN 返回NaN 否则，返回f而且可以用if语句
0 1111 1111 0000 0000 0000 0000 0000 000
只要后面32位中有一位不是0就是NaN
首先判断 是否是NaN
将uf的符号位变为0，得到的数若比0x7f80000大，即为NaN。
13.返回unsigned uf的整型数的二进制形式
/*
* float_f2i - Return bit-level equivalent of expression (int) f
* for floating point argument f.
* Argument is passed as unsigned int, but
* it is to be interpreted as the bit-level representation of a
* single-precision floating point value.
* Anything out of range (including NaN and infinity) should return
* 0x80000000u.
* Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
* Max ops: 30
* Rating: 4
* 返回unsigned uf的整型数的二进制形式
* 参数和结果都会被作为unsigned返回，但是会表示为二进制的单精度浮点值
* 任何超过范围的数都应该返回 0x80000000u.
* 允许的操作符: 任何整数或者无符号数操作符包括： ||, &&. also if, while
* 最多操作符数目: 30
* 分值: 4
*/
int float_f2i(unsigned uf) {
int x,y;
unsigned mini=0x80000000;
x=(uf>>23)&0xff;//阶码域
y=(uf&0x007fffff)^0x00800000;
if(x>158)
return mini;
if(x<127)
return 0;
else if(((uf>>31)&0x1)==1)
{
if(x>150)
return ((~(y<<(x-150)))+1);
else
return ((~(y>>(150-x)))+1);
}
else
{
if(x>150)
return (y<<(x-150));
else
return (y>>(150-x));
}
}
设计思想：将uf左移23位并与0xff相与来取出阶码域；设置y来取出小数域，并令其第23位为1，为了规格化的值隐含的以1开头的表示。
当阶码的值E大于31时，表示float转化为int会溢出，或者出现阶码域全为1的情况；当阶码的值小于0，返回0；当uf最高位为1时，判断x与150的大小，决定移位的方向，并以补码形式将数值存储；当uf最高位为0时，判断x与150大小，决定移位的方向。