more answers

Apress · Jul 20, 2017 · f4c361e · f4c361e
1 parent f30058b
commit f4c361e
Show file tree

Hide file tree

Showing 68 changed files with 345 additions and 58 deletions.
diff --git a/questions/answers/001.md b/questions/answers/001.md
@@ -50,4 +50,4 @@ The difference is that the CF is a result of an unsigned overflow (not enough bi
 
 
 
- [next](2.md)
+ +++ [next](002.md)
diff --git a/questions/answers/002.md b/questions/answers/002.md
@@ -27,4 +27,4 @@ There might be additional points, which are of a little importance to us, such a
 
 
 
-[prev](1.md) [next](3.md)
+[prev](001.md) +++ [next](003.md)
diff --git a/questions/answers/003.md b/questions/answers/003.md
@@ -18,4 +18,4 @@ a couple of CPU cycles
 
 
 
-[prev](2.md) [next](4.md)
+[prev](002.md) +++ [next](004.md)
diff --git a/questions/answers/004.md b/questions/answers/004.md
@@ -36,4 +36,4 @@ Examples of such instructions are:
 
 
 
-[prev](3.md) [next](5.md)
+[prev](003.md) +++ [next](005.md)
diff --git a/questions/answers/005.md b/questions/answers/005.md
@@ -25,4 +25,4 @@ representation -- internal interrupt).
 
 
 
-[prev](4.md) [next](6.md)
+[prev](004.md) +++ [next](006.md)
diff --git a/questions/answers/006.md b/questions/answers/006.md
@@ -20,4 +20,4 @@ model are trying to solve?
 
 
 
-[prev](5.md) [next](7.md)
+[prev](005.md) +++ [next](007.md)
diff --git a/questions/answers/007.md b/questions/answers/007.md
@@ -29,4 +29,4 @@ Here is the full list (16 general purpose registers):
 
 
 
-[prev](6.md) [next](8.md)
+[prev](006.md) +++ [next](008.md)
diff --git a/questions/answers/008.md b/questions/answers/008.md
@@ -15,4 +15,4 @@ What is the purpose of stack pointer?
 
 
 
-[prev](7.md) [next](9.md)
+[prev](007.md) +++ [next](009.md)
diff --git a/questions/answers/009.md b/questions/answers/009.md
@@ -20,4 +20,4 @@ Being unable to reason about the amount of elements in stack, this question has
 
 
 
-[prev](8.md) [next](10.md)
+[prev](008.md) +++ [next](010.md)
diff --git a/questions/answers/010.md b/questions/answers/010.md
@@ -19,4 +19,4 @@ So, no, we are unable to reason about the amount of elements in stack at all.
 
 
 
-[prev](9.md) [next](11.md)
+[prev](009.md) +++ [next](011.md)
diff --git a/questions/answers/011.md b/questions/answers/011.md
@@ -21,4 +21,4 @@ vs nine for `mov` with operand).
 
 
 
-[prev](10.md) [next](12.md)
+[prev](010.md) +++ [next](012.md)
diff --git a/questions/answers/012.md b/questions/answers/012.md
@@ -20,4 +20,4 @@ The assembly programs return the exit status by passing it to the
 
 
 
-[prev](11.md) [next](13.md)
+[prev](011.md) +++ [next](013.md)
diff --git a/questions/answers/013.md b/questions/answers/013.md
@@ -17,4 +17,4 @@ The program exit status (return code).
 
 
 
-[prev](12.md) [next](14.md)
+[prev](012.md) +++ [next](014.md)
diff --git a/questions/answers/014.md b/questions/answers/014.md
@@ -17,4 +17,4 @@ Use `man ascii` to view the full ASCII table with the symbol codes.
 
 
 
-[prev](13.md) [next](15.md)
+[prev](013.md) +++ [next](015.md)
diff --git a/questions/answers/015.md b/questions/answers/015.md
@@ -41,4 +41,4 @@ its value, becoming `1111` in binary, or  `0xF`.
 
 
 
-[prev](14.md) [next](16.md)
+[prev](014.md) +++ [next](016.md)
diff --git a/questions/answers/016.md b/questions/answers/016.md
@@ -43,4 +43,4 @@ Some examples (all producing exactly the same code):
 
 
 
-[prev](15.md) [next](17.md)
+[prev](015.md) +++ [next](017.md)
diff --git a/questions/answers/017.md b/questions/answers/017.md
@@ -16,4 +16,4 @@ are exactly the same.
 
 
 
-[prev](16.md) [next](18.md)
+[prev](016.md) +++ [next](018.md)
diff --git a/questions/answers/018.md b/questions/answers/018.md
@@ -46,4 +46,4 @@ stored in reverse order, the least significant byte being the first.
 
 
 
-[prev](17.md) [next](19.md)
+[prev](017.md) +++ [next](019.md)
diff --git a/questions/answers/019.md b/questions/answers/019.md
@@ -76,4 +76,4 @@ syscall
 
 
 
-[prev](18.md) [next](20.md)
+[prev](018.md) +++ [next](020.md)
diff --git a/questions/answers/022.md b/questions/answers/022.md
@@ -20,4 +20,4 @@ TODO
 
 
 
-[prev](21.md) [next](23.md)
+[prev](021.md) +++ [next](023.md)
diff --git a/questions/answers/023.md b/questions/answers/023.md
@@ -25,4 +25,4 @@ They are parts of the same regiser:
 
 
 
-[prev](22.md) [next](24.md)
+[prev](022.md) +++ [next](024.md)
diff --git a/questions/answers/024.md b/questions/answers/024.md
@@ -17,4 +17,4 @@ By using `r9d`, `r9w` and `r9b` to access the double word (32 bit), word (16 bit
 
 
 
-[prev](23.md) [next](25.md)
+[prev](023.md) +++ [next](025.md)
diff --git a/questions/answers/025.md b/questions/answers/025.md
@@ -14,4 +14,4 @@ For example, `call`, `ret`, `push`, `pop`.
 
 
 
-[prev](24.md) [next](26.md)
+[prev](024.md) +++ [next](026.md)
diff --git a/questions/answers/026.md b/questions/answers/026.md
@@ -0,0 +1,44 @@
+
+# Question 26
+
+
+Which ones of these instructions are incorrect and why?
+```asm
+mov [rax], 0
+cmp [rdx], bl
+mov bh, bl
+mov al, al
+add bpl, 9
+add [9], spl
+mov r8d, r9d
+mov r3b, al
+mov r9w, r2d
+mov rcx, [rax + rbx + rdx]
+mov r9, [r9 + 8*rax]
+mov [r8+r7+10], 6
+mov [r8+r7+10], r6
+```
+
+
+# Answer
+
+
+
+The incorrect instructions are listed below:
+
+```asm
+mov [rax], 0                ; We don't know whether we should write 8, 4, 2 or 1 byte
+                            ; Change to e.g. `mov dword [rax], 0`
+
+mov r3b, al                 ; NASM does not support r0-r7 names, only r8-r15 
+mov r9w, r2d                ; NASM does not support r0-r7 names, only r8-r15    
+
+mov rcx, [rax + rbx + rdx]  ; displacement should be an immediate value
+                            ; can not use register for it 
+mov [r8+r7+10], 6           ; No size specified, NASM does not support r7
+mov [r8+r7+10], r6          ; NASM does not support r6 or r7 
+```
+
+
+
+[prev](025.md) +++ [next](027.md)
diff --git a/questions/answers/027.md b/questions/answers/027.md
@@ -19,4 +19,4 @@ Enumerate the Callee Saved Registers
 
 
 
-[prev](26.md) [next](28.md)
+[prev](026.md) +++ [next](028.md)
diff --git a/questions/answers/028.md b/questions/answers/028.md
@@ -23,4 +23,4 @@ them in a general purpose fashion anyway.
 
 
 
-[prev](27.md) [next](29.md)
+[prev](027.md) +++ [next](029.md)
diff --git a/questions/answers/029.md b/questions/answers/029.md
@@ -15,4 +15,4 @@ It holds the address of the next instruction to be executed.
 
 
 
-[prev](28.md) [next](30.md)
+[prev](028.md) +++ [next](030.md)
diff --git a/questions/answers/030.md b/questions/answers/030.md
@@ -15,4 +15,4 @@ Sign Flag, it is set when the computation result is negative.
 
 
 
-[prev](29.md) [next](31.md)
+[prev](029.md) +++ [next](031.md)
diff --git a/questions/answers/031.md b/questions/answers/031.md
@@ -15,4 +15,4 @@ Zero Flag, it is set when the computation result is zero.
 
 
 
-[prev](30.md) [next](32.md)
+[prev](030.md) +++ [next](032.md)
diff --git a/questions/answers/032.md b/questions/answers/032.md
@@ -0,0 +1,35 @@
+
+# Question 32
+
+
+Describe the effects of the following instructions:
+\beginitemize
+\item `sar `
+\item `shr`
+\item `xor`
+\item `jmp`
+\item `ja`, `jb` and similar ones.
+\item `cmp`
+\item `mov`
+\item `inc`,`dec`
+\item `add`
+\item `imul, mul`
+\item `sub`
+\item `idiv, div`
+\item `call, ret`
+\item `push, pop`
+\enditemize
+
+
+
+# Answer
+
+
+
+
+Refer to the second volume of [Intel 64 and IA-32 Architectures Software Developer's Manual].
+
+
+
+
+[prev](031.md) +++ [next](033.md)
diff --git a/questions/answers/033.md b/questions/answers/033.md
@@ -15,4 +15,4 @@ own, because it is not stored in memory cells.
 
 
 
-[prev](32.md) [next](34.md)
+[prev](032.md) +++ [next](034.md)
diff --git a/questions/answers/034.md b/questions/answers/034.md
@@ -35,4 +35,4 @@ _no:
 
 
 
-[prev](33.md) [next](35.md)
+[prev](033.md) +++ [next](035.md)
diff --git a/questions/answers/035.md b/questions/answers/035.md
@@ -44,4 +44,4 @@ flags are set, the jump occurs. However, from my experience, it is useless. If y
 
 
 
-[prev](34.md) [next](36.md)
+[prev](034.md) +++ [next](036.md)
diff --git a/questions/answers/036.md b/questions/answers/036.md
@@ -16,4 +16,4 @@ are exactly the same.
 
 
 
-[prev](35.md) [next](37.md)
+[prev](035.md) +++ [next](037.md)
diff --git a/questions/answers/037.md b/questions/answers/037.md
@@ -25,4 +25,4 @@ _label:
 
 
 
-[prev](36.md) [next](38.md)
+[prev](036.md) +++ [next](038.md)
diff --git a/questions/answers/038.md b/questions/answers/038.md
@@ -19,4 +19,4 @@ The assembly programs return the exit status by passing it to the
 
 
 
-[prev](37.md) [next](39.md)
+[prev](037.md) +++ [next](039.md)
diff --git a/questions/answers/039.md b/questions/answers/039.md
@@ -17,4 +17,4 @@ lea rax, [rax + rax*8]
 
 
 
-[prev](38.md) [next](40.md)
+[prev](038.md) +++ [next](040.md)
diff --git a/questions/answers/040.md b/questions/answers/040.md
@@ -21,4 +21,4 @@ jl label
 
 
 
-[prev](39.md) [next](41.md)
+[prev](039.md) +++ [next](041.md)
diff --git a/questions/answers/041.md b/questions/answers/041.md
@@ -33,4 +33,4 @@ In Big Endian, the bytes are also stored in a  natural order:
 
 
 
-[prev](40.md) [next](42.md)
+[prev](040.md) +++ [next](042.md)
diff --git a/questions/answers/042.md b/questions/answers/042.md
@@ -24,4 +24,4 @@ mov rax, [rdx + 8*rcx + 42]
 ```
 
 
-[prev](41.md) [next](43.md)
+[prev](041.md) +++ [next](043.md)
diff --git a/questions/answers/043.md b/questions/answers/043.md
@@ -12,4 +12,4 @@ Where does the program execution start?
 From the `_start` label.
 
 
-[prev](42.md) [next](44.md)
+[prev](042.md) +++ [next](044.md)
diff --git a/questions/answers/044.md b/questions/answers/044.md
@@ -19,4 +19,4 @@ Because of __little endian__:
 
 
 
-[prev](43.md) [next](45.md)
+[prev](043.md) +++ [next](045.md)
diff --git a/questions/answers/045.md b/questions/answers/045.md
@@ -21,4 +21,4 @@ Decypher this segment selector: `0x08`.
 * ring = 0, this is the 0-th protection ring, we are actually in the most privileged mode.
 
 
-[prev](44.md) [next](46.md)
+[prev](044.md) +++ [next](046.md)
diff --git a/questions/answers/046.md b/questions/answers/046.md
@@ -0,0 +1,27 @@
+
+# Question 46
+
+
+Read about microcode in general and processor pipelines.
+
+
+# Answer
+
+
+
+
+Microcode is the program code one level _below_ assembly, that is used to 
+encode the logic of complex instructions. It is not accessible to programmer
+and virtually everything about it is a trade secret of computer manufacturer.
+
+The processor pipeline allows you to execute multiple microcode instructions 
+at time, if they use different parts of CPU. It is a great performance
+booster.
+
+This document contains a good insight on these topics:
+[The microarchitecture of Intel, AMD and VIA CPUs: An optimization guide for assembly programmers and
+compiler makers](http://www.agner.org/optimize/microarchitecture.pdf)
+
+
+
+[prev](045.md) +++ [next](047.md)
diff --git a/questions/answers/047.md b/questions/answers/047.md
@@ -17,4 +17,4 @@ There is little difference between these for caches or for virtual memory,
 because the latter can be viewed as a particular type of cache.
 
 
-[prev](46.md) [next](48.md)
+[prev](046.md) +++ [next](048.md)
diff --git a/questions/answers/048.md b/questions/answers/048.md
@@ -33,4 +33,4 @@ Anonymous pages correspond to no file in filesystem, thus their respective
 fields contain stub zeros.
 
 
-[prev](47.md) [next](49.md)
+[prev](047.md) +++ [next](049.md)
diff --git a/questions/answers/049.md b/questions/answers/049.md
@@ -13,4 +13,4 @@ We recommend the following article:
 [https://www.cs.umd.edu/class/sum2003/cmsc311/Notes/Memory/fully.html](https://www.cs.umd.edu/class/sum2003/cmsc311/Notes/Memory/fully.html)
 
 
-[prev](48.md) [next](50.md)
+[prev](048.md) +++ [next](050.md)
diff --git a/questions/answers/050.md b/questions/answers/050.md
@@ -15,4 +15,4 @@ A continuous area of memory is called a region if:
 
 
 
-[prev](49.md) [next](51.md)
+[prev](049.md) +++ [next](051.md)
diff --git a/questions/answers/051.md b/questions/answers/051.md
@@ -18,4 +18,4 @@ kills the process right away. You will see the error message `Segmentation fault
 
 
 
-[prev](50.md) [next](52.md)
+[prev](050.md) +++ [next](052.md)
diff --git a/questions/answers/052.md b/questions/answers/052.md
@@ -16,4 +16,4 @@ handled by OS. It usually involves killing current process right away. You
 will see the error message `Segmentation fault`.
 
 
-[prev](51.md) [next](53.md)
+[prev](051.md) +++ [next](053.md)
diff --git a/questions/answers/053.md b/questions/answers/053.md
@@ -19,4 +19,4 @@ is handled by OS, usually by killing the process. You will see an error message
 `Bus error`.
 
 
-[prev](52.md) [next](54.md)
+[prev](052.md) +++ [next](054.md)
Original file line number	Diff line number	Diff line change
Expand Up		@@ -50,4 +50,4 @@ The difference is that the CF is a result of an unsigned overflow (not enough bi



		[next](2.md)
		+++ [next](002.md)
Original file line number	Diff line number	Diff line change
Expand Up		@@ -27,4 +27,4 @@ There might be additional points, which are of a little importance to us, such a



		[prev](1.md) [next](3.md)
		[prev](001.md) +++ [next](003.md)
Original file line number	Diff line number	Diff line change
Expand Up		@@ -18,4 +18,4 @@ a couple of CPU cycles



		[prev](2.md) [next](4.md)
		[prev](002.md) +++ [next](004.md)
Original file line number	Diff line number	Diff line change
Expand Up		@@ -36,4 +36,4 @@ Examples of such instructions are:



		[prev](3.md) [next](5.md)
		[prev](003.md) +++ [next](005.md)
Original file line number	Diff line number	Diff line change
Expand Up		@@ -25,4 +25,4 @@ representation -- internal interrupt).



		[prev](4.md) [next](6.md)
		[prev](004.md) +++ [next](006.md)
Original file line number	Diff line number	Diff line change
Expand Up		@@ -20,4 +20,4 @@ model are trying to solve?



		[prev](5.md) [next](7.md)
		[prev](005.md) +++ [next](007.md)
Original file line number	Diff line number	Diff line change
Expand Up		@@ -29,4 +29,4 @@ Here is the full list (16 general purpose registers):



		[prev](6.md) [next](8.md)
		[prev](006.md) +++ [next](008.md)
Original file line number	Diff line number	Diff line change
Expand Up		@@ -15,4 +15,4 @@ What is the purpose of stack pointer?



		[prev](7.md) [next](9.md)
		[prev](007.md) +++ [next](009.md)
Original file line number	Diff line number	Diff line change
Expand Up		@@ -20,4 +20,4 @@ Being unable to reason about the amount of elements in stack, this question has



		[prev](8.md) [next](10.md)
		[prev](008.md) +++ [next](010.md)
Original file line number	Diff line number	Diff line change
Expand Up		@@ -19,4 +19,4 @@ So, no, we are unable to reason about the amount of elements in stack at all.



		[prev](9.md) [next](11.md)
		[prev](009.md) +++ [next](011.md)