CPSC213/2014W1 Midterm EXTRA Practice

Transcription

1 CPSC213/2014W1 Midterm EXTRA Practice DEC/HEX/BIN NUMERACY 1. Convert into decimal: 1a. 0x33 1b. 0x57 1c. 0xaf 1d. 0x7a 1e. 0x1234 1f. 0x69bd 1g. 0x1a64 1h. 0xdead 2. Convert into hex numbers of the specified width: 2a. 227 (8 bits) 2b. 113 (8 bits) 2c. 43 (8 bits) 2d. 241 (8 bits) 2e (16 bits) 2f (16 bits) 2g (16 bits) 2h (16 bits) 2i (32 bits) 2j (32 bits) 3. Convert into binary: 3a. 0x7158 3b. 0x44ac 3c. 0x90e4 3d. 0x3456 3e. 0x f. 0x9a30bcde 3g. 0xdeadbeef 3h. 0x416c706e 4. Evaluate and produce an answer in hex (in 16-bits width): 4a. (0x1943 & 0xA673) 0x1137 4b. 0x8ffd + (0x9097 ~0x3333) 5. Convert to hex, using two s complement representation and 16-bits width: 5a b

2 ENDIANNESS 6. The following style of output is known as a hexdump and shows in a convenient way the bytes stored in memory (in this case, 256 bytes at addresses 0x3080 to 0x317F. As its name implies, all the values and addresses are displayed in hexadecimal. Use it to answer the following questions A 0B 0C 0D 0E 0F D4 D2 EF 1B 2E 32 6A C7 9A B8 5E EC 8D 0D A4 FD 3090 ED B6 AA CF 0D 7B E1 E7 AB E BC 98 7C 30A0 8B 0F 84 3A EF BE C8 A0 70 C0 6F E8 78 7D 30B0 DB D1 A0 44 2F 07 8C 1E 8C D2 74 CA 4E FE 01 DB 30C0 8D C4 AF F4 AB 25 DA FF E2 B1 F CB 30D0 59 A9 8A AF 54 D0 AC 68 B5 AC 9E D7 34 AA 30E0 C1 33 BA 22 F3 A7 1F 08 9C 4A 68 6E 78 CE B2 3D 30F B1 84 BB 51 8A C 9E 38 F3 4E E B C 53 B7 51 3A 64 F AC A E FE F2 B4 AB 6A D4 4F 1D 77 2F B0 6F 9F A2 DD 3E A B FC 5A 8C 6C 7B 4F 3130 DD 9D D0 5E FE 8E 1E 13 D7 95 F2 B7 85 A F2 4B 54 D0 96 FE 96 B1 F8 91 BD F8 01 5F 7D F B D 04 2C 10 8A C7 F2 88 C1 A3 A F C A2 0D 0A 1C E1 53 2A F8 DA 91 DB 6a. What is the value (in hex) of the little-endian 4-byte integer stored at location 0x3108? 6b. What is the value (in hex) of the big-endian 2-byte short stored at location 0x30AC? 6c. What is the value (in hex) of the little endian 8-byte long long stored at location 0x3100? 6d. At what address is stored the 4-byte big-endian integer 0xbdf8015f? 6e. At what address is stored the 2-byte little-endian short 0xb1e2? 6f. At what address is stored the 8-byte big-endian long long 0x4f1d772f1228b06f? ALIGNMENT 7a. What is the largest power-of-2 size that the address 0x4090 is aligned to? 7b. What is the largest power-of-2 size that the address 4095 is aligned to? 7c. Is address aligned for accessing an 8-byte long long? 7d. Is address 0xcafebabe aligned for accessing a 2-byte short? 2

3 MEMORY LAYOUT, C 8. Consider this fragment of C containing several global variables: int a; int b[3] = { 1, 2, 3 ; int *c; int d = 15; 8a. Write the corresponding SM213 Asm for a data section that begins at 0x2000. Assume that all the variables are allocated contiguously and in order. You do not need to provide comments. 8b. What is the address of b[1]? 8c. What is the address of c? 8d. Write the corresponding SM213 Asm instructions required to implement this statement d = b[*(c+a) + b[1]] - 7; 3

4 9. Write the types of the following C declarations, following this format: int a; int *b; int c[5]; a is an int b is a pointer to int c is an array of 5 ints 9a. int **d; 9b. int *f[2]; 9c. char (*f)[2][2]; 9d. short (*g[5])[7]; 10. Given these C declarations and their positions in memory, and assuming that pointers and integers are both 4 bytes: int a[5] = { 2, 4, 0, 3, 1 ; /* a is at address 400 */ int *b[2] = { &a[2], &a[4] ; /* b is at address 500 */ int **c = &b[1]; /* c is at address 512 */ Write down the addresses and values of a[3], b[0], b[1], and c: 10a. a[3] 10b. b[0] 10c. b[1] 10d. c What are the types and numerical values of the following expressions? (e.g. the type of a[2] is int, and its value is 0): 10e. a[a[2]] 10f. b[0]+2 10g. *b[1] 10h. *c 10i. *(b[1]-1) 10j. &b[a[**c]] 10k. Write the C statement that corresponds to the following SM213 Asm (using the declarations above). You may add comments to each line if you find it helpful. ld $512, r0 ld (r0), r0 ld $400, r1 ld 16(r1), r2 not r2 inc r2 shl $2, r2 add r2, r0 ld (r0), r0 ld 8(r0), r3 ld $18, r4 and r4, r3 st r3, 12(r1) 4

5 11. Consider this structure declaration: struct S { int a; char *b[2]; short c; char d; int *e; struct T { char aa[30]; int bb; int **cc; float dd; f; double g; ; 11a. Using the sizes char = 1, short = 2, int = 4, float = 4, double = 8, and pointer = 4, list the offset relative to the start of struct S, in bytes, of each primitive type contained in this structure next to it, assuming each primitive type is aligned to its size. Write +n, before each offset that is preceded by one or more padding bytes, with n being the number of bytes of padding inserted. 11b. What is the size of this structure (in bytes)? 11c. Assuming that an instance of struct S, named s, is located at address 3072, what is the address of s.f.aa[5]? 11d. Assuming that an instance of struct S, named t, is located at address 10984, what is the address of t.b[1]? 5

6 SM213 ASM 12a. Next to each SM213 instruction, write out the series of bytes (in hex; you may omit the 0x prefix) corresponding to their encoding. You may use the SM213 Instruction Table. Remember that SM213 is a big-endian machine. ld $0x2000, r0 ld $0x , r1 ld 4(r0), r3 inc r3 mov r3, r5 not r5 inc r5 add r5, r3 ld $7, r4 add r4, r5 st r5, 4(r0) ld (r0,r5,4), r7 shl $4, r3 shr $3, r1 and r1, r3 12b. Write out the SM213 instructions corresponding to this series of (hex) bytes: FF FF BE EF 34 E FC 6F 51 F0 00 6

7 13a. A br instruction is located at address 0x4108. What are the smallest and largest addresses it can branch to? 13b. A j instruction is located at address 0x1034. What are the smallest and largest addresses it can jump to? 13c. SM213 is big-endian, but not all machines are. Assuming that global variable a is a pointer to an array of integers, and that global variable n is the number of integers in this array, write a fragment of SM213 Asm which will swap the bytes of each element in this array to change their byte order from little to big endian (or vice-versa - the transformation is bijective.) You MAY use all 8 registers, MUST NOT write anything besides this fragment of code, and MUST NOT modify neither the variables a nor n. A halt at the end is not required. Use comments as necessary to explain. (Hint: beware of sign-extension, and help yourself by drawing a diagram of which bits need to move where.) 7

8 13d. Decompile to a fragment of C (i.e. what could appear inside the body of a function, but without the function itself) the following code. Add comments as needed to guide the process. L0: L1: L2: ld $i, r0 ld (r0), r0 ld $j, r1 ld (r1), r1 ld $0, r2 bgt r0, L1 not r0 inc r0 br L1 add r1, r2 dec r0 bgt r0, L0 ld $i, r0 ld (r0), r0 bgt r0, L2 not r2 inc r2 ld $k, r1 st r2, (r1) 8

9 14. The SM213 has only two memory addressing modes, base+offset and base+index. These compute an effective address of a register + immediate constant, and register + register * 4, respectively. Other instruction sets, such as the x86, have more. In particular, x86 has a base+offset+index mode, which computes an effective address of register + immediate constant + register * 4. Suppose that this addressing mode was also added to SM213, so that these two instructions were available, with their associated semantics: ld o(rs,ri,4), rd r[d] <- m[r[s] + r[i] + o] st rs, o(rd,ri,4) m[r[d] + r[i] + o] <- r[s] 14a. Explain the circumstances in which this addressing mode would be useful. 14b. Given the following C global declaration, and statement: struct S { int u; int v; int q[10]; *s; s->q[s->u] = s->q[s->v]; Write an SM213 Asm fragment to implement the statement, making use of the instructions added above with this new addressing mode. 14c. Although this addressing mode does not exist in SM213, explain how its effect can be achieved using the regular SM213 addressing modes. 14d. Referring to the declaration above, implement this statement without the use of these new addressing modes (i.e. with only the existing base+offset and base+index modes): s->u = s->q[s->v]; 9

10 Java C OOP 15a. Given this Java class and a method within it: public class Foo { public int x; public int y;... public int barber(int q, int z) { x = q; y = z + x; return x*y;... Write the corresponding definition for a C function Foo barber() which takes as its first parameter a pointer to struct Foo, and performs the same operations. int Foo_barber(struct Foo *this, int q, int z) { 15b. Given this Java class and the declarations of methods within it, public class Barbell { public int p; public int q;... public Barbell(int i, int j) {... public Foo barbarian() {... public int quux(int z) {... public void barbie(foo f) {... and the corresponding C method signatures void Barbell_ctor(struct Barbell *this, int i, int j); /* constructor */ struct Foo *Barbell_barbarian(struct Barbell *this); int Barbell_quux(struct Barbell *this, int z); void Barbell_barbie(struct Barbell *this, struct Foo *f); and this fragment of Java which uses these classes Barbell b = new Barbell(2, 3); Barbell b2 = new Barbell(4, 5); Foo f; b.quux(7); f = b.barbarian(); b2.barbie(f); b2.quux(f.barber(3, 3)); b.barbie(f); 10

11 write the corresponding fragment of C code. (You do not need to deallocate any constructed objects explicitly.) 15c. What are two differences between C and Java arrays? DYNAMIC MEMORY ALLOCATION For each of the following C programs, determine if there are any memory errors, and if so, describe in detail what the error is. You are NOT required to describe any fix for the error. 16a. int *f() { int *u = malloc(16*sizeof(int)); u[1] = 15; return u; int main() { int *r = f(); r[3] = 42; return 0; 11

12 16b. int f(int *p) { p[2] = 4; free(p); int main() { f(malloc(4*sizeof(int)); return 0; 16c. int *p; void g(int n) { p = malloc(n); *p = n; void h() { int i; for(i=0;i<16;i++) p[i] = i; free(p); int main() { g(16*sizeof(int)); h(); *p = 12; return 0; 12

13 16d. int *f1(int *v) { *v = 8; return v + 1; int main() { int i; int *q = malloc(16*sizeof(int)); int *p = q + 1; for(i=0;i<15;i++) { p = f1(p); *p = i; free(p); return 0; 16e. void f(int *p) { *(p+1) = 1337; free(p); void g(int *p) { *(p+2) = 666; free(p); int main() { int *m = malloc(4*sizeof(int)); int *n = m; f(m); g(n); return 0; 13

14 16f. void foo(int *k) { k = malloc(12*sizeof(int)); k[0] = 1; k[1] = 3; k[2] = 3; k[3] = 7; 11[k] = 0xdeadbeef; int main() { int *q; foo(q); *(q+5) = 6; free(q); return 0; 16g. int g; int e; void foo(int *r) { *r = g++; void bar(int *s) { e += *s; free(s); int main() { int *a = malloc(4*sizeof(int)), *b = malloc(4*sizeof(int)), *c = malloc(4*sizeof(int)), *d = malloc(4*sizeof(int)); foo(a); foo(b+1); foo(c+2); foo(d+3); bar(a); bar(b+1); bar(c+2); bar(d+3); return 0; 14

15 16h. int g; int e; void foo(int *r, int n) { r[n] = g++; void bar(int *r, int n) { e += *(r+n); free(r-n); int main() { int *a = malloc(4*sizeof(int)), *b = malloc(4*sizeof(int)), *c = malloc(4*sizeof(int)), *d = malloc(4*sizeof(int)); foo(a, 0); bar(a, 0); foo(b, 1); bar(b, 1); foo(c, 2); bar(c, 2); foo(d, 3); bar(d, 3); return 0; 15

16 PROCEDURES AND STACK 17a. Suppose a function is declared as int foo(int a, int b, int c, int d, int *e); and is compiled to SM213 by a compiler using the standard stack-based calling convention (arguments pushed from right-toleft). When its first instruction executes, the value of r5 is 0x7F0C. At what address is argument d? (Show work.) 17b. Given the declaration above, and assuming that the label foo is defined, compile this function to SM213 Asm, following the standard calling convention. The first instruction of the function has already been completed for you. int bar(int x, int y) { int z = 2; return foo(x, y+1, 8, z, &z) - 4; bar: deca r5 # allocate space for return address 16

17 18. The sequence of instructions to perform a procedure call, gpc $6, r6 j some_func # set return address # call some_func should seem familiar by now, as should the sequence for a return (a leaf procedure may not need to pop the return address from the stack): ld (r5), r6 inca r5 j (r6) # pop return address from stack # return Consider the semantics of these sequences of instructions carefully, when answering the following questions. 18a. Is the gpc instruction absolutely necessary in order for procedure calls/returns (including recursion) to work, or is it merely a convenience? If it is absolutely necessary, explain why; otherwise, give an example showing how it is possible to perform a procedure call/return (with recursion) without it. 18b. Is the jump indirect (e.g. j (r6)) instruction absolutely necessary in order for procedure calls/returns (with recursion) to work, or is it merely a convenience? If it is absolutely necessary, explain why; otherwise, give an example showing how it is possible to perform a procedure call/return (with recursion) without it. 17