深入理解计算机系统家庭作业第三章
***3.54
***写出decode2的原型
*/
int decode2(int x ,int y, int z)
{
int a = z - y;
int b = (a << 15) >> 15;
return (x ^ a) * b;
}/*
***3.55
*/
typedef long long ll_t;
void store_prod(ll_t *dest, ll_t x, int y){
*dest = x*y;
}
// dest at %ebp+8, x at %ebp + 12, y at %ebp + 20
movl 12(%ebp), %esi //将x的低位存到%esi
movl 20(%ebp), %eax //将y存到%eax
movl %eax, %edx
sarl $31, %edx //将(y >> 31)存到%edx
movl %edx, %ecx
imull %esi, %ecx //计算x_low * (y >> 31)存到%ecx
movl 16(%ebp), %ebx //将x的高位存到%ebp
imull %eax, %ebx //计算x_high * y
addl %ebx, %ecx //计算 x_high * y + x_low * (y >> 31) 存到%ecx
mull %esi //计算y * x_low 的无符号64位乘积
leal (%ecx, %edx), %edx //将64位乘积的高位与x_high * y + x_low * (y >> 31)得到最终结果的高位
movl 8(%ebp), %ecx
movl %eax, (%ecx)
movl %edx, 4(%ecx) //将结果写入目的内存地址说明：
该汇编代码其实是y扩展至64位再进行两个64位数的乘积然后进行截断得到的。
事实上有：
y *{signed} x =
(y_high * 2^32 + y_low) *{signed} (x_high * 2^32 + x_low) =
y_high *{signed} x_high * 2^64 +
y_high *{signed} x_low * 2^32 +
y_low *{signed} x_high * 2^32 +
y_low *{signed} x_low(有符号的x_low与无符号的x_low相等，故可用mull指令)
而y_high *{signed} x_high由于乘以2^64，所以对结果不会产生影响。
/*
***3.56写出loop函数原型
*/
int loop(int x, int n)
{
int result = 0x55555555;
int mask;
for(mask = 0x80000000;mask !=0; mask = (unsigned)mask >> (n & 0xFF))
{
result ^= x & mask;
}
return result;
}
/*
***3.57用条件传送指令写函数cread_alt
*/
int cread_alt(int *xp){
int a = 0;
return *(xp ? xp : &t);
}思路：原来函数中的错误就是无论xp是否为NULL，都对其发生了间接引用。将引用符号放在最外面，那么当xp为NULL时，
条件传送指令将临时变量a的地址传送至%eax，故不会产生对xp的间接引用。下面贴上产生的汇编代码：
subl $16, %esp
.cfi_def_cfa_offset 20
movl 20(%esp), %eax
movl $0, 12(%esp)
leal 12(%esp), %edx
testl %eax, %eax
cmove %edx, %eax
movl (%eax), %eax
addl $16, %esp
.cfi_def_cfa_offset 4
ret/*
***3.58
*/
int switch3(int *p1,int *p2,mode_t action)
{
int result = 0;
switch(action){
case MODE_A:
result = *p1;
*p1 = *p2;
break;
case MODE_B:
result = *p1 + *p2;
*p2 = result;
break;
case MODE_C:
*p2 = 15;
result = *p1;
break;
case MODE_D:
*p2 = *p1;
result = 17;
break;
case MODE_E:
result = 17;
break;
default:
result = -1;
break;
}
return result;
}/*
***3.59根据反汇编代码补全c语言代码
*/
int switch_prob(int x,int n)
{
int result = x;
switch(n){
case 40:
case 42:
result <<=3;
break;
case 43:
result >>=3
break;
case 44:
result = (result<<3) - result;
case 45:
result *= result;
result += 17;
break;
default:
result += 17;
break;
}
return result;
}/*
***3.60
*/
A. &A[i][j][k] = Xa + L(i * S*T + j * T + K)
B. 根据汇编代码可得，9*j存在寄存器%eax中，63*i存在寄存器%edx中，对照公式可得S=7，T=9；
最后一句movl $2772 %eax 可知R = 2772/S/T/4 = 11
/*
***循环中的值的数量从6个减少到5个
*/
int car_prod_ele(int n,int A[n][n],int B[n][n],int i,int k)
{
int j;
int result = 0;
int *ap = A[i];
int *bp = &B[0][k];
for(j = 0; j < n; j++)
{
result += *ap * *bp;
ap++;
bp += n;
}
return result;
}这题没有想到很好的解法，以上代码经测试是将4n放到寄存器%ebp当中，实际上并没有减少循环值的数量，望高人指点。
/*
***3.62
*/
A. M的值为19
B. %edi保存i,%ecx保存j
C.
void transpose(int A[M][M]){
int i,j;
for(i = 0;i < M;i++)
{
int *p1 = &A[0][i];
for(j = 0;j < i;j++)
{
int *p2 = &A[i][0];
int t = *p1; //交换对称的两个值
*p1 = *p2;
*p2 = t;
p1 += M; //改变两个元素的指针
p2 += 1;
}
}
}/*
***3.63
*/
E1 = 3n
E2 = 2n - 1
说明：%esi中存放的值为3n，再对照18行可知E1 = 3n;
每次指针的值变化为8n - 4，可知E2 = 2n - 1。
/*
***3.64
*/
A. 8(%ebp)存放返回值result的地址；12(%ebp)存放s1.p；16(%ebp)存放s1.v。
B. 从高到低依次为s2.sum，s2.prod，s1.v，s1.p，&s2
C. 传递结构体参数时，结构体各参数从高到低依次压入栈中
D. 在8(%ebp)处有一个指向返回值结构体的指针，指针的值作为返回地址，根据返回地址写入值
/*
***3.65
*/
A=3
B=7
首先分析B，t的首地址和u的首地址相差20个字节，t本身占4字节，所以short数组s[B]占16个字节，根据四字节对齐的原则，可知B=7或8；
short x[A][B]占44个字节，当B=8时，A无解，当B=7时，可得A=3.
/*
***3.66
*/
A. CNT = 7;
B. struct a_struct{
int idx;
int x[6];
}
这个题最难的地方是汇编代码的第十行，对照汇编代码和C代码可知，汇编代码的第十二行对应C代码的第九行，汇编代码的十三行对应C代码的十一行。
经过分析（事实上带有一些猜测），第十行add的第一个操作数就是ap->idx的值，加上7i的原因是a_struct中有7个整型变量（这与我们计算ap->idx的地址
为bp + 28i + 4）也是吻合的；然后我们分析汇编代码的十三行，前面的0x8应该看做0x4 + 0x4，第一个0x4是b_struct中left占的字节数，第二个0x4是a_struct
中idx占的字节数，所以可知idx是结构体第一个变量，另外，x是长度为6的数组。
/*
***3.67
*/
A. 下列字段的偏移量值是多少（以字节为单位）
e1.p: 0
e1.x: 4
e2.y: 0
e2.next: 4
B. 这个结构总共需要8个字节
C.
void proc (union ele *up)
{
up->e2.next->e1.x = *(up->e2.next->e1.p) - up->e2.y;
}
/*
***3.68写一个good_echo函数，对任意长度的输入行都能工作（即时超过了缓冲区）
*/
#define N 50
void good_echo()
{
char buf[N];
while(fgets(buf,N,stdin) != NULL)
{
for(int i = 0;i < N;i++)
{
if(buf[i] == '1')
return;
if(buf[i] == '\0')
break;
putchar(buf[i]);
}
}
}
/*
***3.69写出函数trace
*/
A. 给出该函数的C版本，使用while循环
long trace(tree_ptr tr)
{
long result = 0;
while(tp)
{
result = tp->val;
tp = tp->left;
}
return result;
}
B. 该函数得到最左边叶子的val值。
/*
***3.70
*/
A. 生成这个函数的C版本
long traverse(tree_ptr tp)
{
if(!tp)
return 0x7fffffffffffffff;
long min_left = traverse(tp ->left);
long min_right = traverse(tp ->right);
long min = min_left < min_right ? min_left : min_right;
min = min < (tp ->val)? min : (tp ->val);
return min;
}
B. 这个函数是求树中val的最小值，若为空树，则返回0x7fffffffffffffff；