Assembly Language Final
mov edi,pString*** mov eax,0**** L1: cmp BYTE PTR [edi],0**** je L2**** inc edi**** inc eax**** jmp L1**** L2:
Assume that pString is a doubleword that contains the offset of a string. This code will will set EAX to the length of the string? (The length should not count the string's null byte.)
arguments pushed on stack; procedure called; EBP pushed on stack; EBP set to ESP
Assuming that a procedure contains no local variables, a stack frame is created by which sequence of actions at runtime?
False
For any two integers n and m, ((n XOR m) OR m) produces n.
DX=FFFFh, AX=80C0h
Given that EAX contains FFFF80C0h, the contents of DX and AX after executing the CWD instruction
mov esi,0**** mov edi,0**** mov ecx,NUMROWS**** mov ax,0**** L1: add ax,twArray[esi+edi]**** add esi,(ROWSIZE * TYPE twArray)**** loop L1
Given the following declaration of a two-dimensional array,write a code to calculate the sum of theelements in column 0:::::: .data ROWSIZE = 5 NUMROWS = 4 twArray WORD NUMROWS DUP( ROWSIZE DUP(?) )
shr ax,1 **** rcr dx,1 **** shr ax,1 **** rcr dx,1
Given the following two assignments to AX and DX, which block of instructions will cause DX to equal 4025h and AX to equal 1AD2h ::::: mov ax,6B49h ***** mov dx,0095h
3
How many daughters did Charles Ingalls have in Little House on the Prairie?
3.78 liters
How many liters are there in the U.S. gallon?
change CMPSB to CMPSW and change JA to JG, and change JB to JL
If var1 and var2 were changed to type SWORD in the following code, then this change(s) would have to be made to the instructions in the code segment: ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: .data*** var1 BYTE 10**** var2 BYTE 20**** var3 BYTE 30**** .code********** mov esi,OFFSET var2**** mov edi,OFFSET var1**** cmpsb**** ja L1**** jb L2**** je L3
True
In Protected mode, immediate values pushed on the stack are always 32 bits long.
CF = 0, ZF = 0, SF = 0
These are the values of CF, ZF, and SZF after the following instructions are executed : ::: mov al,00110011b**** test al,2
Chrysler
This US auto maker produced a car called the Cirrus
Delta
This airline company is named after a Greek letter
:mov ax,0FFFFh**** mov esi,OFFSET arrayW**** mov ecx,SIZEOF arrayW**** std**** rep stosw
This block of code will fill all elements of arrayW with FFFFh:::: arrayW WORD 50 DUP(?)
mov ebx,edx ***** shl edx,5 ****** shl ebx,2 ***** add edx,ebx*****ALSO ::::::::mov ebx,edx*** shl ebx,5*** shl edx,2*** add edx,ebx
This blocks of instructions multiplies the contents of the EDX register by 36
MOV EAX, 500 ***** call Delay
This code causes a 500 millisecond delay, using a library procedure.
and al, 11111100 ****jz L3****jmp L
This code clears bits 0 and 1 in AL. Then , if the destination operand is equal to 0, the code should jump to label L3, otherwise, it will jump to label L4
mov Max, eax ; assume Max = eax**** cmp Max, ebx**** jae done**** mov Max, ebx ; Max = ebx**** done:
This code computes the Max of unsigned EAX and EBX
MOV ESI, OFFSET array**** MOV ECX, LENGHTOF array**** MOV EBX, TYPE array**** call dumpMem
This code displays the following array in hexadecimal, using the DumpMem procedure from the link library:::::array DWORD 10h,20h,30h,40h
mov ecx, LENGTHOF mystring**** mov esi, OFFSET mystring**** L1: or BYTE PTR [esi], 20h ; set bit 5**** inc esi**** loop L1****
This code converts the string mystring to lower case
MOV EDX, OFFSET str1****call WriteString
This code will display the following string to standard output::::: str1 BYTE "Display this string",0
0100 0010
This is the binary value of AL after the following instructions have executed ::::::: mov al,10000101b **** clc **** rcr al,1
1100 0000 0010 0111
This is the binary value of AX after the following instructions have executed ::::: mov ax,0000 0000 1001 1101 b **** mov bx,1010 1010 1000 1011 b **** shrd ax,bx,2
0000 0001 0011 1011
This is the binary value of AX after the following instructions have executed :::::: mov ax,0000 0000 1001 1101 b **** mov bx,1010 1010 1000 0000 b **** shld ax,bx,1
10111110
This is the content of AL after the following instructions execute :::: mov al,00111100b**** or al,82h
00001011
This is the content of AL after the following instructions execute :::: mov al,11001111b***** and al,00101011b
00h
.data**** 2: str1 BYTE "AAAX",0**** 3: str2 BYTE 10 DUP(0FFh)**** 4: .code**** 5: mov edi,0**** 6: L1: mov al,[str1+edi]**** 7: cmp al,0**** 8: je L2 9: mov [str2+edi],al 10: inc edi**** 11: jmp L1**** 12: L2:****** If we changed lines 7, 8, and 9 to the following, what value would be stored at offset [str2+4] after the loop finished? 7: mov [str2+edi],al****** 8: cmp al,0***** 9: je L2
0FFh
.data**** 2: str1 BYTE "AAAX",0**** 3: str2 BYTE 10 DUP(0FFh)**** 4: .code**** 5: mov edi,0**** 6: L1: mov al,[str1+edi]**** 7: cmp al,0**** 8: je L2**** 9: mov [str2+edi],al**** 10: inc edi**** 11: jmp L1**** 12: L2: After the code executes, what value will be stored at offset [str2+4]?
CaseTable BYTE 'a'**** DWORD afoo**** EntrySize = ($ - CaseTable)**** BYTE 'b'**** DWORD bfoo**** BYTE 'c'**** DWORD cfoo**** BYTE 'd' **** DWORD dfooo BYTE 'e'**** DWORD efoo**** BYTE 'f' **** DWORD ffooo NumberOfEntries = ($ - CaseTable) / EntrySize
A case table that can call these prosedures if the user selects : a,b,c,d,e,f :::afoo, bfoo, cfoo, dfoo, efoo, ffoo. It must calculate table entry size and how many entries are there in the table.
IsDigit PROC**** cmp al,'0' ; ZF = 0**** jb ID1**** cmp al,'9' ; ZF = 0**** ja ID1**** test ax,0 ; ZF = 1**** ID1: ret**** IsDigit ENDP
A code for a procedure that receives a character in AL. Sets the Zero flag if the character is a decimal digit.
True
A link library is a file containing procedures that have been assembled into machine code.
3 times
Consider the MySub procedure listed below. If it were called with N = 5, how many times would the RET instruction execute? MySub PROC, N:DWORD cmp N,7 je L1 mov eax,N inc eax INVOKE MySub,eax L1: ret MySub ENDP
MySub is recursive and MySub terminates when N is equal to 7 are both correct
Consider the procedure named MySub in the code below. Which of the following statements are true? MySub PROC, N:DWORD cmp N,7 je L1 mov eax,N inc eax INVOKE MySub,eax L1: ret MySub ENDP
cmp ebx, ecx**** jna L1**** cmp ebx, edx**** jna L1**** jmp L2**** L1: cmp edx, eax**** jna L3**** L2: mov X, 1**** jmp next **** L3: mov x, 2 **** next:
In assembly language ::: if(ebx >ecx AND ebx >edx> OR (edx >eax) then X = 1 **** else X = 2
ASCII code of "3"
In this Example, if we change line 7 to "repe scasb", what value will be moved to BL after line 8 executes?::::::::: 1: .data**** 2: str1 BYTE "1324A2342424",0**** 3: .code**** 4: mov edi,OFFSET str1**** 5: mov al,'A'**** 6: cld**** 7: repne scasb**** 8: mov bl,[edi]****
at var2
In this example ESI point at this variable after the CMPSB instruction executes::::.data*** var1 BYTE 10**** var2 BYTE 20**** var3 BYTE 30**** .code********** mov esi,OFFSET var2**** mov edi,OFFSET var1**** cmpsb**** ja L1**** jb L2**** je L3
L1
In this example the program will jump to this label ::::.data*** var1 BYTE 10**** var2 BYTE 20**** var3 BYTE 30**** .code********** mov esi,OFFSET var2**** mov edi,OFFSET var1**** cmpsb**** ja L1**** jb L2**** je L3
00040015h
In this example, assume that str1 is located at offset 00040010h. What will be the value of EDI after line 7 executes?:::::1: .data**** 2: str1 BYTE "1324A2342424",0**** 3: .code**** 4: mov edi,OFFSET str1**** 5: mov al,'A'**** 6: cld**** 7: repne scasb**** 8: mov bl,[edi]****
cannot be determined
In this xample , if we change line 6 to "std", what value will be moved to BL after line 8 executes?::::1: .data**** 2: str1 BYTE "1324A2342424",0**** 3: .code**** 4: mov edi,OFFSET str1**** 5: mov al,'A'**** 6: cld**** 7: repne scasb**** 8: mov bl,[edi]****
In Ohio it is, if done without a hunting license!
Is it illegal to catch mice?
7: cmp al,'z' ***** 8: ja L2***** 9: and BYTE PTR [esi],11011111b***** 10: L2: inc esi***** 11: jmp L1***** 12: L3: ret*****
Suppose we want to convert the letters in myString to uppercase (by clearing bit 5 of each character). Lines 1 through 6 are the first part of the implmentation::::: .data**** myString BYTE "abCDefg123hij",0**** .code**** 1: mov esi,OFFSET myString**** 2: L1: mov al,[esi]**** 3: cmp al,0 **** 4: je L3 **** 5: cmp al,'a'**** 6: jb L2**** WRITE THE REMINING INSTRUCTIONS:::::
FALSE
T/F A WHILE loop can be constructed with a CMP instruction at the bottom of the loop, followed by a conditional jump instruction.
FALSE
T/F The PUSH instruction increments the stack pointer (by 2 or 4) and copies the operand into the stack at the location pointed to by the stack pointer.
FALSE
T/F The assembler knows the exact address of a library procedure
TRUE
T/F This code sequences assigns the value 10h to EBX:::: mov edx,20h**** push edx**** mov ecx,10h**** push ecx**** pop ebx**** pop edx
True
The DIV instruction generates a divide overflow condition when the quotient is too large to fit into the destination operand.
False
The EBP register points to the last value pushed on the stack.
False
The Irvine32.lib procedures cannot directly call functions in the kernel32.lib library.
True
The JA instruction is used when comparing unsigned integers.
False
The JCXZ instruction jumps to a target label when the ECX register is equal to zero.
False
The JL instruction jumps if the (unsigned) first operand is less than the (unsigned) second operand.
ESI
The MOVSB instruction uses this register as the source operand
False
The OR instruction can be used to set an operand's value to zero.
False
The OR instruction modifies the Sign and Zero flags, but not the Parity flag.
False
The PUSH instruction copies a value from the stack to an operand before incrementing the stack pointer.
True
The PUSHAD instruction pushes all the 32-bit general-purpose registers on the stack.
repeats an instruction while the Zero flag is set
The REPE prefix does the following:
False
The ReadChar procedure echoes its input character on the screen.
False
The SAR and SHR instructions perform the same operation.
True
The SAR instruction is suitable for signed integers.
False
The SHL instruction is suitable only for signed integers.
True
The XOR instruction can be used to generate the one's complement of an integer.
True
The binary value of AL after the following instructions have executed is 00011010. mov al,01101011b shr al,2
False
The binary value of AL after the following instructions have executed is 11101101. mov al, 01101011b rol al,2
1 1 0
The contents of CF, SF, and ZF after these instructions are executed ::: mov al,5 cmp al,7
False
The destination operand of the AND instruction must be a register.
True
The destination operand of the IMUL instruction must always be a register.
True
The first value pushed on a stack is the last one to be removed.
mov eax,var1**** cmp eax,var2**** jle ifpart**** mov var3,6**** mov var4,7**** jmp next**** ifpart:**** mov var3,10**** next:
The following code in assembly Language:::if (var1 <= var2) **** {**** var3 = 10;**** }**** else**** {**** var3 = 6;**** var4 = 7;**** }
cmp ebx, ecx**** ja L1****cmp ebx, val1****ja L1****mov X, 2****jmp next****L1: mov X, 1****next:
The following code in assembly language ::: if(ebx > ecx ) OR (EBX >val1 ) then x=1 **** else X = 2
cmp val1, ecx****jna L1**** cmp ecx, edx****jna L1****mov x, 1**** jmp next****L1: mov X, 2****next
The following pseudo code in assembly language::: if(val1 >ecx) AND (ecx >edx ) then X = 1**** else X = 2;
cannot be determined
The hexadecimal values of DX and AX after the following instructions have executed :::: mov ax,3456h **** mov dx,12h **** mov bx,10h **** div bx
False
The runtime stack is managed by the operating system, with no support from the CPU.
1. EAX, 2. ESI
The two registers containing: 1. an integer before calling WriteDec and 2. the starting address of data when calling DumpMem
.DATA***sum DWORD 0***sample DWORD 50*** array DWORD 10, 60, 20, 33, 72, 89, 45, 65, 72,18****arraySize = ($ - array) / TYPE array****.CODE *** mov EAX, 0****mov EBX, sample***mov ESI, 0 **** MOV ECX, arraySize****L1: CMP ESI,ECX***JNL L5****cmp array[ESI*4], EDX****JNG L4**** add EAX, array[ESI*4]****L4 : inc ESI**** jmp L1****L5 : mov sum, EAX
This code is functionally equivalent to example 6.5.3 but has fewer instructions
****MOV EAX, 1000*****call RandomRange ***** calWriteDec
This code uses library procedures to generate a single unsigned pseudorandom integer between 0 and 999 and write it to standard output:
call ReadInt*****call WriteInt
This code writes a sequence of statements that read a signed integer from standard input and write the same integer to standard output. Use library procedures.
mySub PROC USES EAX EBX
This codes a PROC declaration for a procedure named MySub. It uses the USES operator to preserve the EAX and EBX registers.
United States
This country produces the greatest volume of beer per year
kernel32.lib
This file acts as a bridge between Irvine32.lib and kernel32.dll
call writeInt
This instruction ( a function call ) writes the contents of EAX to standard output as a signed decimal integer?
and dl,0Eh**** cmp dl,0Eh**** je L4****
This instruction cause a jump to label L4 if bits 1, 2, and 3 are all set in the DL register?
CLD
This instruction causes the ESI and EDI registers to be incremented by the MOVSB instruction
ROL AL, 4
This instruction converts the value 6Fh in AL to the value F6h.
RCR AL, 1
This instruction copies the value of the Carry flag into bit 7 of AL, and shifts all existing bits in AL one position to the right.
POPFD
This instruction pops the stack into the FLAGS register
PUSHFD
This instruction pushes the 32 bit FLAGS registers on the stack
shr ebx,3
This instruction will divide the unsigned integer in EBX by 8 (using shifts only)
shl ebx,5
This instruction will multiply the integer in EBX by 32 (using shifts only)
1010 1110
This is the binary value of AL after the following instructions have executed :::: mov al,01101011b **** stc **** rcl al,2
10100011
This is the content of AL after the following instructions execute ::::mov al,94h xor al,37h
:: top:**** mov eax,int2**** cmp eax,int1**** jl L3**** add ebx,2**** cmp ebx,int2**** jg L1**** mov ebx,int1**** jmp L2**** L1: mov ebx,0**** L2: jmp top**** L3:
This is the correct implementation of the following pseudocode::::while( int2 >= int1 )**** {**** add ebx,2**** if( ebx > int2)**** mov ebx,0**** else**** mov ebx,int1**** }
mov val1,ebx**** cmp ebx,val2**** jg L1**** cmp val2,eax**** jg L1**** mov ebx,2**** jmp L2**** L1: mov ebx,1**** L2:
This is the correct implementation of the following pseudocode:::if( val1 > val2 || val2 > eax )**** mov ebx,1;**** else**** mov ebx,2;
cmp eax, ebx***jna L1****mov DL, 5****jmp L2****L1: mov dl,6 200
This is the equivalent Assembly Language code of the following C++ code. Assume that integers are unsigned. NO .IF directive allowed: if( eax > ebx ) mov dl,5; ******* else mov dl,6;
DX = 012Ah, AX = D692h
This is the hexadecimal values of DX and AX after the following instructions have executed ::::: mov ax,6B49h **** mov dx,0095h **** shl ax,1 **** rcl dx,1 ****
5
This is the value of EAX when the following sequence of instructions has executed::::: push 5***** push 10***** pop ebx***** pop eax
20
This is the value of EAX when the following sequence of instructions has executed::::: push 5***** push 10***** push 20***** pop eax
Cannot be determined
This is the value of ECX when the following sequence of instructions has executed::::: push 5**** push 10**** pop ebx**** pop eax**** pop ecx
WriteHex
This library procedure writes an unsigned 32-bit integer to standard output in hexadecimal format
KEY = 239 ; Can be any byte value**** BUFMAX = 128**** .DATA**** buffer BYTE BUFMAX+1 DUP(0)**** bufSize DWORD BUFMAX**** .CODE **** mov ecx, bufSize ; loop counter**** mov esi, 0 ; index 0 in buffer**** L1:**** xor buffer[esi], KEY ; translate a byte**** inc esi ; point to next byte**** loop L1****
This loop uses the XOR instruction to transform every character in a string called buffer into a new value ( produce a cipher text)
7
This many red stripes are on the U.S. flag
Elvis Presley
This person of non royal origins was known as "The King"?
Gotoxy
This procedure locates the cursor at a specific row and column on the screen
Rhone River
This river runs through both Lyon and Marseilles?
"The quick brown fox jumps over a lazy dog."
This sentence contains every letter of the English Alphabet.
mov eax, -16 ****cdq*****mov ebx, 5****idiv ebx
This sequence of instructions divides -16 by 5, using the IDIV instruction. It uses the EBX register as a divisor.
mov BL, AL ***** and BL, 0011 1111b
This sequence of two instructions copies bits 0-5 from AL to bits 0-5 in BL. Bits 6-7 in BL are cleared, and AL is unchanged.
shr AL, 4 **** mov BL, AL
This sequence of two instructions copies the integer in bits 4-7 from the AL register into bits 0-3 of the BL register. The upper 4 bits of AL are cleared, as will the upper 4 bits of BL.
mov EBX, EAX ; make copy **** shl EAX, 4 ; EAX * 16 ****shl EBX, 1 ; EBX * 2 ****add EAX, EBX ; answer
This series of instructions multiplies EAX by 18, using a combination of shift, MOV, and ADD instructions.
AND ax, 00FFh
This single instruction uses 16 bit operand that clear the high 8 bits of AX and does not change the low 8 bits
MOV EAX, black + ( white * 16)
This statement moves a video color constant to EAX. The constant should represent black text on a white background, (using the constants in the Irvine32.inc file)
Niagara Falls
This waterfalls are between Lake Erie and Lake Ontario
DX = 0042h, AX = 0F63h
This will be the hexadecimal values of DX and AX after the following instructions have executed :::::: mov dx,000Fh **** mov ax,6342h **** mov bx,100h **** div bx
DX = FFFFh, AX = FFE0h
This will be the hexadecimal values of DX and AX after the following instructions have executed::::: mov dx, -16 **** mov ax,2 **** imul dx
OF = 1 ( DX = 0000h, AX = 8000h, so DX is not a sign extension of AX)
This will be the value of the Overflow flag after the following instructions have executed ::::: mov dx,800h **** mov ax,10h **** imul dx
INVOKE permits you to pass arguments separated by commas.
What advantages does INVOKE offer over the CALL instruction?
"Infart" and "Utfart."
What is "entrance" and "driveway" in Swedish?
The operand order is the same between PUSH and POP, as in: push eax push ebx ...(some other code) pop eax pop ebx
When saving and restoring registers with PUSH and POP, which of the following is a mistakes?
False
When the MUL BL instruction executes, the upper half of the product ends up in the DX register.
False
When the MUL BX instruction executes, the 32-bit product ends up in the EAX register.
True
When the product fits completely into the lower register of the product, IMUL sign extends the product into the upper product register. MUL, on the other hand, zero extends the product
True
When using the Irvine32 library, you should always push 32-bit values on the stack.
after MOV EBP,ESP, subtract 8 from the stack pointer (ESP)
Which action must take place inside a procedure to reserve space on the stack for two doubleword local variables?
Champagne is about 3 times as much pressure as in a tire
Which is greater - The pressure in an automobile tire, or the pressure in a bottle of champagne?
Zurich
Which is the financial centre and main city of Switzerland?
INVOKE mySub, PTR myList
Which of the following INVOKE statements is invalid?
MySub PROC val1:WORD, val2:DWORD
Which of the following PROC statement is invalid?
LOCAL wArray[50]:SWORD
Which of the following defines an array local variable consisting of 50 signed words?
push ebp mov ebp,esp sub esp,4
Which of the following shows the procedure entry code generated by MASM when the LOCAL directive is used to declare a doubleword variable?
Marrakesh ( Morocco )
Which one of these is not on the coast: Venice, San Diego, Reykjavik, Marrakesh, Helsinki, Lisbon
True
With signed operands, the CMP instruction makes the Sign flag equal to the Overflow flag when the destination operand is greater than the source operand.
False
With unsigned operands, the CMP instruction sets the Carry flag when the destination operand is greater than the source operand.
Read10 PROC**** MOV ECX, LENGHTOF myString**** MOV ESI, OFFSET myString**** L1: call ReadChar**** MOV [esi], AL**** INC ESI**** Loop L1**** RET Read10 ENDP
Write a procedure named Read10 that reads exactly ten characters from standard input into an array of BYTE named myString. Use the LOOP instruction with indirect addressing, and call the ReadChar procedure from the book's link library. (ReadChar returns its value in AL.)
ShowBinary PROC**** MOV ECX, LENGHTOF array**** MOV ESI, OFFSET array**** L1: MOV EAX, [esi]**** call WriteBin**** ADD ESI, TYPE array**** Loop L1**** RET**** ShowBinary ENDP
Write a procedure named ShowBinary that displays the following array as a sequence of binary bits, starting with the low-order value (00000010h). Include the use of the LENGTHOF, OFFSET, and TYPE operators, and call the WriteBin procedure::::: array DWORD 10h,20h,30h,40h
; ( first 3 statements may be in any order)**** mov edi, OFFSET arrayD**** mov ecx, LENGHTOF arrayD**** cld*** repz scasd**** mov eax, [edi-4]
Write a sequence of instructions that use SCASD to search arrayD for the first value that is not the same as the current contents of EAX. When the search is completed, move the value you have found into EAX:::: arrayD SDWORD 50 DUP(?)
; ( first 4 statements may be in any order)*** mov eax, 7FFFFFFFh**** mov edi, OFFSET arrayD**** mov ecx, LLENGHTOF arrayD**** cld**** rep stosd
Write a sequence of instructions that use STOSD to fill each position of arrayD with the largest possible 32-bit positive integer: arrayD SDWORD 20 DUP(?)
; ( first 4 statements may be in any order )**** mov esi, arrayA + count - 4**** mov edi, arrayB + count - 4**** mov ecx, count**** std**** repe cmpsd**** ; (next 2 assignments may be in any order)**** mov eax, [esi+4] ; from arrayA ***** mov ebx, [edi +4] ; from arrayB
Write a sequence of instructions using CMPSD that compare arrayA to arrayB in reverse order. After the comparison, move the first pair of non-matching array values to EAX and EBX.::::: COUNT = 5**** arrayA DWORD COUNT DUP(?)**** arrayB DWORD COUNT DUP(?)****
(first 4 statements may be in any order)**** mov ecx, LENGHTOF arrayA**** mov esi, OFFSET arrayA**** mov edi, OFFSET arrayB**** cld******** L1 : LODSB**** or al, 0010 0000**** stosb**** LOOP L1
Write a sequence of instructions using LODSB and STOSB that copy each character from arrayA to arrayB, converting it to lowercase in the process. Note: setting bit 5 in an uppercase character will convert it to lowercase:::: arrayA BYTE "ABCDEFGHI"**** arrayB BYTE LENGTHOF arrayA DUP(0)
