2.2: Bitwise Logical Operations

Transcription

1 2.2: Bitwise Logical Operations Topics: Introduction: logical operations in C/C++ logical operations in MIPS In 256 lecture, we looked at bitwise operations in C/C++ and MIPS. We ll look at some simple programs to illustrate these operations in this exercise. Steps: Earlier, we copied logical.cc from ~whsu/csc256/labs/progs/: /* logical.cc: demonstrates bitwise logical operations in C/C++ */ #include <iostream> using namespace std; int main() { int x = 0x456789ab, y = 0x9abcdef0, z; int w1 = 0xaaaaaaaa; unsigned int w2 = 0xaaaaaaaa; cout << "x = " << hex << x << " y = " << hex << y << endl; z = ~x; cout << "~x = " << hex << z << endl; z = x & y; cout << "x & y = " << hex << z << endl; z = x y; cout << "x y = " << hex << z << endl; z = x ^ y; cout << "x ^ y = " << hex << z << endl; cout << "\nw1 = " << hex << w1 << " w2 = " << w2 << endl; z = w1 << 3; cout << "w1 << 3 = " << hex << z << endl; CSc 256 Lab Manual 1

2 z = w1 >> 3; cout << "w1 >> 3 = " << hex << z << endl; z = w2 >> 3; cout << "w2 >> 3 = " << hex << z << endl; } All it does is perform some logical operations and print the results. Let s compile and run it: unixlab% g++ logical.cc -o logical unixlab%./logical x = ab y = 9abcdef0 ~x = ba x & y = 2488a0 x y = dfffdffb x ^ y = dfdb575b w1 = aaaaaaaa w2 = aaaaaaaa w1 << 3 = w1 >> 3 = f w2 >> 3 = unixlab% Let s go through the results and make sure we understand how the operations work. x is initialized to 0x456789ab, which in binary is y is initialized to 0x9abcdef0, which in binary is ~x means the bitwise not of x. We complement each bit of x to get ~x = In hexadecimal, this is 0xba987654, which agrees with what the program printed. x & y means the bitwise and of x and y: x & y = In hexadecimal, this is 0x002488a0, which agrees with what the program printed. (Leading CSc 256 Lab Manual 2

3 zeros are usually not printed.) x y means the bitwise or of x and y: x y = In hexadecimal, this is 0xdfffdffb, which agrees with what the program printed. x ^ y means the bitwise xor of x and y: x ^ y = In hexadecimal, this is 0xdfdb575b, which agrees with what the program printed. Finally, we come to the shift operations. w1 and w2 are both initialized to 0xaaaaaaaa, except w1 is a signed int and w2 is an unsigned int. 0xaaaaaaaa in binary is w1 << 3 means w1 shift left 3 bits: w1 << 3 = In hexadecimal, this is 0x , which agrees with what the program printed. w1 >> 3 means w1 shift right 3 bits; since w1 is a signed int, the sign bit is extended: w1 >> 3 = In hexadecimal, this is 0xf , which agrees with what the program printed. w2 >> 3 means w2 shift right 3 bits; since w2 is an unsigned int, bits of zero are padded into the most significant bits: w2 >> 3 = In hexadecimal, this is 0x , which agrees with what the program printed. Logical.s is the MIPS version of logical.c. Since spim does not allow us to print integers in hexadecimal, we'll use the print command in spim to show integers in hex. # logical.s: demonstrates bitwise logical operations in MIPS CSc 256 Lab Manual 3

4 .data.text.globl bk main: li $s0, 0x456789ab li $s1, 0x9abcdef0 li $s2, 0xaaaaaaaa bk: not $t0,$s0 and $t0,$s0,$s1 or $t0,$s0,$s1 xor $t0,$s0,$s1 sll $t0,$s2,3 srl $t0,$s2,3 sra $t0,$s2,3 li $v0,10 syscall We'll invoke spim, set a breakpoint at bk, and run the program: lo "logical.s" bre bk run Breakpoint encountered at 0x pr $s0 Reg 16 = 0x456789ab ( ) Reg 17 = 0x9abcdef0 ( ) Reg 18 = 0xaaaaaaaa ( ) We step through the next instruction not $t0, $s0. The bitwise not of 0x456789ab is 0xba987654: step [0x ] 0x nor $8, $16, $0 $t0,$s0 pr $t0 Reg 8 = 0xba ( ) ; 13: not We step through the next instruction and $t0, $s0, $s1. The bitwise and of 0x456789ab and 0x9abcdef0 is 0x002488a0: step CSc 256 Lab Manual 4

5 [0x c] 0x and $8, $16, $17 ; 14: and pr $t0 Reg 8 = 0x002488a0 ( ) $t0,$s0,$s1 We step through the next instruction or $t0, $s0, $s1. The bitwise or of 0x456789ab and 0x9abcdef0 is 0xdfffdffb: step [0x ] 0x or $8, $16, $17 $t0,$s0,$s1 pr $t0 Reg 8 = 0xdfffdffb ( ) ; 15: or We step through the next instruction xor $t0, $s0, $s1. The bitwise xor of 0x456789ab and 0x9abcdef0 is 0xdfdb575b: step [0x ] 0x xor $8, $16, $17 $t0,$s0,$s1 pr $t0 Reg 8 = 0xdfdb575b ( ) ; 16: xor We step through the next instruction sll $t0, $s2 3. 0xaaaaaaaa shift left logical by 3 bits is 0x : step [0x ] 0x001240c0 sll $8, $18, 3 ; 18: sll $t0,$s2,3 pr $t0 Reg 8 = 0x ( ) We step through the next instruction srl $t0, $s2 3. 0xaaaaaaaa shift right logical by 3 bits is 0x : step [0x c] 0x001240c2 srl $8, $18, 3 ; 19: srl $t0,$s2,3 pr $t0 Reg 8 = 0x ( ) We step through the next instruction sra $t0, $s2 3. 0xaaaaaaaa shift right arithmetic by 3 bits is 0xf (same as srl, but extend sign bit): CSc 256 Lab Manual 5

6 step [0x ] 0x001240c3 sra $8, $18, 3 ; 20: sra $t0,$s2,3 pr $t0 Reg 8 = 0xf ( ) Summary: In this exercise, we traced through some bitwise logical operations in C/C++ and MIPS assembly language. Bitwise operations are very useful for extracting bitfields (or groups of data bits) from within a word or larger piece of storage. We ll see some of these uses later in the course. CSc 256 Lab Manual 6