Systems Architecture ARM Assembler Strings
|
|
|
- Anis Johnston
- 7 years ago
- Views:
Transcription
1 Systems Architecture ARM Assembler Strings Strings p. 1/16
2 Characters or Strings A string is a sequence of characters ASCII 7-bit (American) character codes One byte per character (char) Unicode International character code Two bytes per (wide) character (wchar) Unicode32 Extended version of Unicode Four bytes per (wide) character (wchar) You need to know which type you are using strlen() Length of ASCII string wcslen() Length of Unicode string Strings p. 2/16
3 Fixed Length / Terminated Strings Fixed Length String is always n characters String is truncated if too long String is padded out if too short Terminated Special character to mark end of string Normally a NUL (0x00) is used char name[10] Fixed Length or Terminated? Terminated if string is short (under 10 chars) Truncated if string is long (over 10 chars) Be careful of buffer overrun Strings p. 3/16
4 Counted Strings First byte (or halfword) is a count which indicates number of characters in string struct counted_string_s { int count; char string[]; }; Used by Pascal, ADA, Basic, Fortran,... Strings p. 4/16
5 Program: strlencr.s 1 ; Find the length of a CR terminated string 2 5 CR EQU 0x0D 6 10 Main 11 LDR R0, =Data1 ; Load the address of the lookup table 12 EOR R1, R1, R1 ; Clear R1 to store count 13 Loop 14 LDRB R2, [R0], #1 ; Load the first byte into R2 15 CMP R2, #CR ; Is it the terminator? 16 BEQ Done ; Yes => Stop loop 17 ADD R1, R1, #1 ; No => Increment count 18 BAL Loop ; Read next char AREA Data1, DATA 27 DCB "Hello, World", CR Strings p. 5/16
6 Program: strlencr.s 1 ; Find the length of a CR terminated string 2 5 CR EQU 0x0D 6 10 Main 11 LDR R0, =Data1 ; Load the address of the lookup table 12 EOR R1, R1, R1 ; Clear R1 to store count 13 Loop 14 LDRB R2, [R0], #1 ; Load the first byte into R2 15 CMP R2, #CR ; Is it the terminator? 16 BEQ Done ; Yes => Stop loop 17 ADD R1, R1, #1 ; No => Increment count 18 BAL Loop ; Read next char AREA Data1, DATA 27 DCB "Hello, World", CR EQU Equate a label CR to 0x0D (13), the string terminator Strings p. 5/16
7 Program: strlencr.s 1 ; Find the length of a CR terminated string 2 5 CR EQU 0x0D 6 10 Main 11 LDR R0, =Data1 ; Load the address of the lookup table 12 EOR R1, R1, R1 ; Clear R1 to store count 13 Loop 14 LDRB R2, [R0], #1 ; Load the first byte into R2 15 CMP R2, #CR ; Is it the terminator? 16 BEQ Done ; Yes => Stop loop 17 ADD R1, R1, #1 ; No => Increment count 18 BAL Loop ; Read next char AREA Data1, DATA 27 DCB "Hello, World", CR CMP Compare the character to the terminator (CR) Easier to read than: CMP R2, 0x0D Strings p. 5/16
8 Program: strlencr.s 1 ; Find the length of a CR terminated string 2 5 CR EQU 0x0D 6 10 Main 11 LDR R0, =Data1 ; Load the address of the lookup table 12 EOR R1, R1, R1 ; Clear R1 to store count 13 Loop 14 LDRB R2, [R0], #1 ; Load the first byte into R2 15 CMP R2, #CR ; Is it the terminator? 16 BEQ Done ; Yes => Stop loop 17 ADD R1, R1, #1 ; No => Increment count 18 BAL Loop ; Read next char AREA Data1, DATA 27 DCB "Hello, World", CR DCB Define a string of characters Strings p. 5/16
9 Program: strlencr.s 1 ; Find the length of a CR terminated string 2 5 CR EQU 0x0D 6 10 Main 11 LDR R0, =Data1 ; Load the address of the lookup table 12 EOR R1, R1, R1 ; Clear R1 to store count 13 Loop 14 LDRB R2, [R0], #1 ; Load the first byte into R2 15 CMP R2, #CR ; Is it the terminator? 16 BEQ Done ; Yes => Stop loop 17 ADD R1, R1, #1 ; No => Increment count 18 BAL Loop ; Read next char AREA Data1, DATA 27 DCB "Hello, World", CR Using conditional execution we could write: ADDNE R1, R1, #1 BNE Loop Strings p. 5/16
10 Program: strlen.s 1 ; Find the length of a null terminated string 2 7 Main 8 LDR R0, =Data1 ; Load the address of the lookup table 9 MOV R1, #-1 ; Start count at Loop 11 ADD R1, R1, #1 ; Increment count 12 LDRB R2, [R0], #1 ; Load the first byte into R2 13 CMP R2, #0 ; Is it the terminator? 14 BNE Loop ; No => Next char STR R1, CharCount ; Store result 17 SWI & AREA Data1, DATA 22 DCB "Hello, World", 0 Strings p. 6/16
11 Program: strlen.s 1 ; Find the length of a null terminated string 2 7 Main 8 LDR R0, =Data1 ; Load the address of the lookup table 9 MOV R1, #-1 ; Start count at Loop 11 ADD R1, R1, #1 ; Increment count 12 LDRB R2, [R0], #1 ; Load the first byte into R2 13 CMP R2, #0 ; Is it the terminator? 14 BNE Loop ; No => Next char STR R1, CharCount ; Store result 17 SWI & AREA Data1, DATA 22 DCB "Hello, World", 0 MOV Initialise R1 to -1 to counter the first increment Strings p. 6/16
12 Program: strlen.s 1 ; Find the length of a null terminated string 2 7 Main 8 LDR R0, =Data1 ; Load the address of the lookup table 9 MOV R1, #-1 ; Start count at Loop 11 ADD R1, R1, #1 ; Increment count 12 LDRB R2, [R0], #1 ; Load the first byte into R2 13 CMP R2, #0 ; Is it the terminator? 14 BNE Loop ; No => Next char STR R1, CharCount ; Store result 17 SWI & AREA Data1, DATA 22 DCB "Hello, World", 0 LDRB Increment pointer (R0) Strings p. 6/16
13 Program: strlen.s 1 ; Find the length of a null terminated string 2 7 Main 8 LDR R0, =Data1 ; Load the address of the lookup table 9 MOV R1, #-1 ; Start count at Loop 11 ADD R1, R1, #1 ; Increment count 12 LDRB R2, [R0], #1 ; Load the first byte into R2 13 CMP R2, #0 ; Is it the terminator? 14 BNE Loop ; No => Next char STR R1, CharCount ; Store result 17 SWI & AREA Data1, DATA 22 DCB "Hello, World", 0 CMP We must check for zero. as LDRB can not set the flags Strings p. 6/16
14 Program: strlen.s (Revised) 1 ; Find the length of a null terminated string 2 7 Main 8 LDR R0, =Data1 ; Load the address of the lookup table 9 MOV R1, #0 ; Set strlen to zero 10 Loop 11 LDRB R2, [R0, R1] ; Read n-th byte 12 ADD R1, R1, #1 ; Increment strlen count 13 TEQ R2, #0 ; Is it the terminator? 14 BNE Loop ; No => Next char STR R1, CharCount ; Store result 17 SWI & AREA Data1, DATA 22 DCB "Hello, World", 0 Strings p. 7/16
15 MOV Program: strlen.s (Revised) 1 ; Find the length of a null terminated string 2 7 Main 8 LDR R0, =Data1 ; Load the address of the lookup table 9 MOV R1, #0 ; Set strlen to zero 10 Loop 11 LDRB R2, [R0, R1] ; Read n-th byte 12 ADD R1, R1, #1 ; Increment strlen count 13 TEQ R2, #0 ; Is it the terminator? 14 BNE Loop ; No => Next char STR R1, CharCount ; Store result 17 SWI & AREA Data1, DATA 22 DCB "Hello, World", 0 Initialise R1 to zero length Strings p. 7/16
16 Program: strlen.s (Revised) 1 ; Find the length of a null terminated string 2 7 Main 8 LDR R0, =Data1 ; Load the address of the lookup table 9 MOV R1, #0 ; Set strlen to zero 10 Loop 11 LDRB R2, [R0, R1] ; Read n-th byte 12 ADD R1, R1, #1 ; Increment strlen count 13 TEQ R2, #0 ; Is it the terminator? 14 BNE Loop ; No => Next char STR R1, CharCount ; Store result 17 SWI & AREA Data1, DATA 22 DCB "Hello, World", 0 LDRB Read start of string + length byte (R0 + R1) Does not change string pointer (R0) Strings p. 7/16
17 TEQ Program: strlen.s (Revised) 1 ; Find the length of a null terminated string 2 7 Main 8 LDR R0, =Data1 ; Load the address of the lookup table 9 MOV R1, #0 ; Set strlen to zero 10 Loop 11 LDRB R2, [R0, R1] ; Read n-th byte 12 ADD R1, R1, #1 ; Increment strlen count 13 TEQ R2, #0 ; Is it the terminator? 14 BNE Loop ; No => Next char STR R1, CharCount ; Store result 17 SWI & AREA Data1, DATA 22 DCB "Hello, World", 0 Test Equality rather than full compare Strings p. 7/16
18 Program: skipblanks.s 5 Blank EQU " " 8 9 Main 10 LDR R0, =Data1 ; load the address of the lookup table 11 MOV R1, #Blank ; store the blank char in R1 12 Loop 13 LDRB R2, [R0], #1 ; load the first byte into R2 14 CMP R2, R1 ; is it a blank 15 BEQ Loop ; if so loop SUB R0, R0, #1 ; otherwise done - adjust pointer 18 STR R0, Pointer ; and store it 19 SWI & AREA Data1, DATA 24 DCB " 7 " Strings p. 8/16
19 Program: skipblanks.s 5 Blank EQU " " 8 9 Main 10 LDR R0, =Data1 ; load the address of the lookup table 11 MOV R1, #Blank ; store the blank char in R1 12 Loop 13 LDRB R2, [R0], #1 ; load the first byte into R2 14 CMP R2, R1 ; is it a blank 15 BEQ Loop ; if so loop SUB R0, R0, #1 ; otherwise done - adjust pointer 18 STR R0, Pointer ; and store it 19 SWI & AREA Data1, DATA 24 DCB " 7 " EQU Define Blank to be a space character Strings p. 8/16
20 Program: skipblanks.s 5 Blank EQU " " 8 9 Main 10 LDR R0, =Data1 ; load the address of the lookup table 11 MOV R1, #Blank ; store the blank char in R1 12 Loop 13 LDRB R2, [R0], #1 ; load the first byte into R2 14 CMP R2, R1 ; is it a blank 15 BEQ Loop ; if so loop SUB R0, R0, #1 ; otherwise done - adjust pointer 18 STR R0, Pointer ; and store it 19 SWI & AREA Data1, DATA 24 DCB " 7 " MOV R1 is the character to ignore Strings p. 8/16
21 Program: skipblanks.s 5 Blank EQU " " 8 9 Main 10 LDR R0, =Data1 ; load the address of the lookup table 11 MOV R1, #Blank ; store the blank char in R1 12 Loop 13 LDRB R2, [R0], #1 ; load the first byte into R2 14 CMP R2, R1 ; is it a blank 15 BEQ Loop ; if so loop SUB R0, R0, #1 ; otherwise done - adjust pointer 18 STR R0, Pointer ; and store it 19 SWI & AREA Data1, DATA 24 DCB " 7 " Eat leading blank s Strings p. 8/16
22 Program: skipblanks.s 5 Blank EQU " " 8 9 Main 10 LDR R0, =Data1 ; load the address of the lookup table 11 MOV R1, #Blank ; store the blank char in R1 12 Loop 13 LDRB R2, [R0], #1 ; load the first byte into R2 14 CMP R2, R1 ; is it a blank 15 BEQ Loop ; if so loop SUB R0, R0, #1 ; otherwise done - adjust pointer 18 STR R0, Pointer ; and store it 19 SWI & AREA Data1, DATA 24 DCB " 7 " SUB Loop always read one character ahead to check if the character is to be ignored So back up pointer by one character Strings p. 8/16
23 Program: padzero.s 5 Blank EQU 6 Zero EQU 0 10 Main 11 LDR R0, =Data1 ; load the address of the lookup table 12 MOV R1, #Zero ; store the zero char in R1 13 MOV R3, #Blank ; and the blank char in R3 14 Loop 15 LDRB R2, [R0], #1 ; load the first byte into R2 16 CMP R2, R1 ; is it a zero 17 BNE Done ; if not, done 19 SUB R0, R0, #1 ; otherwise adjust the pointer 20 STRB R3, [R0] ; and store it blank char there 21 ADD R0, R0, #1 ; otherwise adjust the pointer 22 BAL Loop ; and loop DCB " " Strings p. 9/16
24 EQU Program: padzero.s 5 Blank EQU 6 Zero EQU 0 10 Main 11 LDR R0, =Data1 ; load the address of the lookup table 12 MOV R1, #Zero ; store the zero char in R1 13 MOV R3, #Blank ; and the blank char in R3 14 Loop 15 LDRB R2, [R0], #1 ; load the first byte into R2 16 CMP R2, R1 ; is it a zero 17 BNE Done ; if not, done 19 SUB R0, R0, #1 ; otherwise adjust the pointer 20 STRB R3, [R0] ; and store it blank char there 21 ADD R0, R0, #1 ; otherwise adjust the pointer 22 BAL Loop ; and loop DCB " " Define and use Blank Strings p. 9/16
25 EQU Program: padzero.s 5 Blank EQU 6 Zero EQU 0 10 Main 11 LDR R0, =Data1 ; load the address of the lookup table 12 MOV R1, #Zero ; store the zero char in R1 13 MOV R3, #Blank ; and the blank char in R3 14 Loop 15 LDRB R2, [R0], #1 ; load the first byte into R2 16 CMP R2, R1 ; is it a zero 17 BNE Done ; if not, done 19 SUB R0, R0, #1 ; otherwise adjust the pointer 20 STRB R3, [R0] ; and store it blank char there 21 ADD R0, R0, #1 ; otherwise adjust the pointer 22 BAL Loop ; and loop DCB " " Define and use Zero Strings p. 9/16
26 Program: padzero.s 5 Blank EQU 6 Zero EQU 0 10 Main 11 LDR R0, =Data1 ; load the address of the lookup table 12 MOV R1, #Zero ; store the zero char in R1 13 MOV R3, #Blank ; and the blank char in R3 14 Loop 15 LDRB R2, [R0], #1 ; load the first byte into R2 16 CMP R2, R1 ; is it a zero 17 BNE Done ; if not, done 19 SUB R0, R0, #1 ; otherwise adjust the pointer 20 STRB R3, [R0] ; and store it blank char there 21 ADD R0, R0, #1 ; otherwise adjust the pointer 22 BAL Loop ; and loop DCB " " ADD/SUB Adjust pointer Strings p. 9/16
27 Program: padzero.s 5 Blank EQU 6 Zero EQU 0 10 Main 11 LDR R0, =Data1 ; load the address of the lookup table 12 MOV R1, #Zero ; store the zero char in R1 13 MOV R3, #Blank ; and the blank char in R3 14 Loop 15 LDRB R2, [R0], #1 ; load the first byte into R2 16 CMP R2, R1 ; is it a zero 17 BNE Done ; if not, done 19 SUB R0, R0, #1 ; otherwise adjust the pointer 20 STRB R3, [R0] ; and store it blank char there 21 ADD R0, R0, #1 ; otherwise adjust the pointer 22 BAL Loop ; and loop DCB " " STRB STRB R3, [R0, #-1] We don t need to adjust the pointer Strings p. 9/16
28 Program: padzero.s (written in C) Current Version while (1) { R2 = *(R0++); if ( R2!= R1 ) { break; } R0--; *R0 = R3; R0++; } Strings p. 10/16
29 Program: padzero.s (written in C) Current Version Revised Version while (1) { do { R2 = *(R0++); R2 = *R0; if ( R2!= R1 ) { if ( R2 == R1 ) { break; *(R0++) = R3; } } R0--; } while ( R2 == R1 ); *R0 = R3; R0++; } Strings p. 10/16
30 Program: padzero.s (Revised) 5 Blank EQU 6 Zero EQU 0 10 Main 11 LDR R0, =Data1 ; load the address of the lookup table 12 MOV R1, #Zero ; store the zero char in R1 13 MOV R3, #Blank ; and the blank char in R3 14 Loop 15 LDRB R2, [R0] ; read byte at pointer 16 TEQ R1, R2 ; is it a zero (what we are looking for) 17 STREQB R3, [R0], #1 ; yes => replace with blank/inc pointer 19 BEQ Loop ; Yes => Repeat until not target DCB " " Strings p. 11/16
31 Program: setparity.s (Outer loop) 14 MainLoop 15 LDRB R2, [R0], #1 ;load char into R2 16 MOV R6, R2 ;keep a copy of the original char 17 MOV R2, R2, LSL #24 ;shift so that we are dealing with msb. 28 TST R3, #1 ;is the parity even 29 BEQ Even ;if so branch 30 ORR R6, R6, #0x80 ;otherwise set the parity bit 31 STRB R6, [R5], #1 ;and store the amended char 32 BAL Check 33 Even STRB R6, [R5], #1 ;store unamended char if even 34 Check SUBS R1, R1, #1 ;decrement the character count 35 BNE MainLoop Strings p. 12/16
32 Program: setparity.s (Outer loop) 14 MainLoop 15 LDRB R2, [R0], #1 ;load char into R2 16 MOV R6, R2 ;keep a copy of the original char 17 MOV R2, R2, LSL #24 ;shift so that we are dealing with msb. 28 TST R3, #1 ;is the parity even 29 BEQ Even ;if so branch 30 ORR R6, R6, #0x80 ;otherwise set the parity bit 31 STRB R6, [R5], #1 ;and store the amended char 32 BAL Check 33 Even STRB R6, [R5], #1 ;store unamended char if even 34 Check SUBS R1, R1, #1 ;decrement the character count 35 BNE MainLoop SUBS/BNE Repeat... Until R1 is zero Strings p. 12/16
33 Program: setparity.s (Outer loop) LSL 14 MainLoop 15 LDRB R2, [R0], #1 ;load char into R2 16 MOV R6, R2 ;keep a copy of the original char 17 MOV R2, R2, LSL #24 ;shift so that we are dealing with msb. 28 TST R3, #1 ;is the parity even 29 BEQ Even ;if so branch 30 ORR R6, R6, #0x80 ;otherwise set the parity bit 31 STRB R6, [R5], #1 ;and store the amended char 32 BAL Check 33 Even STRB R6, [R5], #1 ;store unamended char if even 34 Check SUBS R1, R1, #1 ;decrement the character count 35 BNE MainLoop Shift LSByte to MSByte (24 bits) Strings p. 12/16
34 Program: setparity.s (Outer loop) TST 14 MainLoop 15 LDRB R2, [R0], #1 ;load char into R2 16 MOV R6, R2 ;keep a copy of the original char 17 MOV R2, R2, LSL #24 ;shift so that we are dealing with msb. 28 TST R3, #1 ;is the parity even 29 BEQ Even ;if so branch 30 ORR R6, R6, #0x80 ;otherwise set the parity bit 31 STRB R6, [R5], #1 ;and store the amended char 32 BAL Check 33 Even STRB R6, [R5], #1 ;store unamended char if even 34 Check SUBS R1, R1, #1 ;decrement the character count 35 BNE MainLoop Is the parity even test LSBit Strings p. 12/16
35 Program: setparity.s (Outer loop) 14 MainLoop 15 LDRB R2, [R0], #1 ;load char into R2 16 MOV R6, R2 ;keep a copy of the original char 17 MOV R2, R2, LSL #24 ;shift so that we are dealing with msb. 28 TST R3, #1 ;is the parity even 29 BEQ Even ;if so branch 30 ORR R6, R6, #0x80 ;otherwise set the parity bit 31 STRB R6, [R5], #1 ;and store the amended char 32 BAL Check 33 Even STRB R6, [R5], #1 ;store unamended char if even 34 Check SUBS R1, R1, #1 ;decrement the character count 35 BNE MainLoop BEQ/ORR Using conditional execution we can write: ORRNE R6, R6, #0x80 ;add parity if odd STRB R6, [R5], #1 ;store char Strings p. 12/16
36 Program: setparity.s (Inner loop) 18 MOV R3, #0 ;zero the bit counter 19 MOV R4, #7 ;init the shift counter ParLoop 22 MOVS R2, R2, LSL #1 ;left shift 23 BPL DontAdd ;if msb is not a one bit, branch 24 ADD R3, R3, #1 ;otherwise add to bit count 25 DontAdd 26 SUBS R4, R4, #1 ;update shift count 27 BNE ParLoop ;loop if still bits to check Strings p. 13/16
37 Program: setparity.s (Inner loop) 18 MOV R3, #0 ;zero the bit counter 19 MOV R4, #7 ;init the shift counter ParLoop 22 MOVS R2, R2, LSL #1 ;left shift 23 BPL DontAdd ;if msb is not a one bit, branch 24 ADD R3, R3, #1 ;otherwise add to bit count 25 DontAdd 26 SUBS R4, R4, #1 ;update shift count 27 BNE ParLoop ;loop if still bits to check SUBS/BNE Repeat... Until R4 is zero Strings p. 13/16
38 Program: setparity.s (Inner loop) 18 MOV R3, #0 ;zero the bit counter 19 MOV R4, #7 ;init the shift counter ParLoop 22 MOVS R2, R2, LSL #1 ;left shift 23 BPL DontAdd ;if msb is not a one bit, branch 24 ADD R3, R3, #1 ;otherwise add to bit count 25 DontAdd 26 SUBS R4, R4, #1 ;update shift count 27 BNE ParLoop ;loop if still bits to check MOVS/LSL Move bits up one, MSB is echoed in Negative flag Strings p. 13/16
39 Program: setparity.s (Inner loop) 18 MOV R3, #0 ;zero the bit counter 19 MOV R4, #7 ;init the shift counter ParLoop 22 MOVS R2, R2, LSL #1 ;left shift 23 BPL DontAdd ;if msb is not a one bit, branch 24 ADD R3, R3, #1 ;otherwise add to bit count 25 DontAdd 26 SUBS R4, R4, #1 ;update shift count 27 BNE ParLoop ;loop if still bits to check BPL Skip add if positive (MSB is zero) Strings p. 13/16
40 Program: setparity.s (Inner loop) 18 MOV R3, #0 ;zero the bit counter 19 MOV R4, #7 ;init the shift counter ParLoop 22 MOVS R2, R2, LSL #1 ;left shift 23 BPL DontAdd ;if msb is not a one bit, branch 24 ADD R3, R3, #1 ;otherwise add to bit count 25 DontAdd 26 SUBS R4, R4, #1 ;update shift count 27 BNE ParLoop ;loop if still bits to check BPL/ADD Using conditional execution we can avoid the Brach: ADDMI R3, R3, #1 ;inc count if MSB set Strings p. 13/16
41 Program: setparity.s (Revised) 14 MainLoop 15 LDRB R2, [R0], #1 ;load the first byte into R2 16 MOV R6, R2 ;keep a copy of the original char 17 MOV R2, R2, LSL #24 ;shift to deal with msb 18 MOV R3, #0 ;zero the bit counter 19 MOV R4, #7 ;init the shift counter ParLoop 22 MOVS R2, R2, LSL #1 ;shift MSB into Neg flag 23 ADDMI R3, R3, #1 ;inc bit count if MSB is set 24 SUBS R4, R4, #1 ;update shift count 25 BNE ParLoop ;loop if still bits to check 26 TST R3, #1 ;is the parity even 27 ORRNE R6, R6, #0x80 ;set the parity bit if odd 28 STRB R6, [R5], #1 ;and store the amended char 29 SUBS R1, R1, #1 ;decrement the character count 20 BNE MainLoop Strings p. 14/16
42 Program: setparity.s (Revised) 14 MainLoop 15 LDRB R2, [R0], #1 ;load the first byte into R2 16 MOV R6, R2 ;keep a copy of the original char 17 MOV R2, R2, LSL #24 ;shift to deal with msb 18 MOV R3, #0 ;zero the bit counter 19 MOV R4, #7 ;init the shift counter ParLoop 22 MOVS R2, R2, LSL #1 ;shift MSB into Neg flag 23 ADDMI R3, R3, #1 ;inc bit count if MSB is set 24 SUBS R4, R4, #1 ;update shift count 25 BNE ParLoop ;loop if still bits to check 26 TST R3, #1 ;is the parity even 27 ORRNE R6, R6, #0x80 ;set the parity bit if odd 28 STRB R6, [R5], #1 ;and store the amended char 29 SUBS R1, R1, #1 ;decrement the character count 20 BNE MainLoop SUBS/BNE Repeat... Until R1 is zero (outer loop) Strings p. 14/16
43 Program: setparity.s (Revised) LSL 14 MainLoop 15 LDRB R2, [R0], #1 ;load the first byte into R2 16 MOV R6, R2 ;keep a copy of the original char 17 MOV R2, R2, LSL #24 ;shift to deal with msb 18 MOV R3, #0 ;zero the bit counter 19 MOV R4, #7 ;init the shift counter ParLoop 22 MOVS R2, R2, LSL #1 ;shift MSB into Neg flag 23 ADDMI R3, R3, #1 ;inc bit count if MSB is set 24 SUBS R4, R4, #1 ;update shift count 25 BNE ParLoop ;loop if still bits to check 26 TST R3, #1 ;is the parity even 27 ORRNE R6, R6, #0x80 ;set the parity bit if odd 28 STRB R6, [R5], #1 ;and store the amended char 29 SUBS R1, R1, #1 ;decrement the character count 20 BNE MainLoop Shift LSByte to MSByte (24 bits) Strings p. 14/16
44 Program: setparity.s (Revised) 14 MainLoop 15 LDRB R2, [R0], #1 ;load the first byte into R2 16 MOV R6, R2 ;keep a copy of the original char 17 MOV R2, R2, LSL #24 ;shift to deal with msb 18 MOV R3, #0 ;zero the bit counter 19 MOV R4, #7 ;init the shift counter ParLoop 22 MOVS R2, R2, LSL #1 ;shift MSB into Neg flag 23 ADDMI R3, R3, #1 ;inc bit count if MSB is set 24 SUBS R4, R4, #1 ;update shift count 25 BNE ParLoop ;loop if still bits to check 26 TST R3, #1 ;is the parity even 27 ORRNE R6, R6, #0x80 ;set the parity bit if odd 28 STRB R6, [R5], #1 ;and store the amended char 29 SUBS R1, R1, #1 ;decrement the character count 20 BNE MainLoop SUBS/BNE Repeat... Until R4 is zero (inner loop) Strings p. 14/16
45 Program: setparity.s (Revised) 14 MainLoop 15 LDRB R2, [R0], #1 ;load the first byte into R2 16 MOV R6, R2 ;keep a copy of the original char 17 MOV R2, R2, LSL #24 ;shift to deal with msb 18 MOV R3, #0 ;zero the bit counter 19 MOV R4, #7 ;init the shift counter ParLoop 22 MOVS R2, R2, LSL #1 ;shift MSB into Neg flag 23 ADDMI R3, R3, #1 ;inc bit count if MSB is set 24 SUBS R4, R4, #1 ;update shift count 25 BNE ParLoop ;loop if still bits to check 26 TST R3, #1 ;is the parity even 27 ORRNE R6, R6, #0x80 ;set the parity bit if odd 28 STRB R6, [R5], #1 ;and store the amended char 29 SUBS R1, R1, #1 ;decrement the character count 20 BNE MainLoop MOVS/LSL Move bits up one, set Negative flag to MSB Strings p. 14/16
46 Program: setparity.s (Revised) 14 MainLoop 15 LDRB R2, [R0], #1 ;load the first byte into R2 16 MOV R6, R2 ;keep a copy of the original char 17 MOV R2, R2, LSL #24 ;shift to deal with msb 18 MOV R3, #0 ;zero the bit counter 19 MOV R4, #7 ;init the shift counter ParLoop 22 MOVS R2, R2, LSL #1 ;shift MSB into Neg flag 23 ADDMI R3, R3, #1 ;inc bit count if MSB is set 24 SUBS R4, R4, #1 ;update shift count 25 BNE ParLoop ;loop if still bits to check 26 TST R3, #1 ;is the parity even 27 ORRNE R6, R6, #0x80 ;set the parity bit if odd 28 STRB R6, [R5], #1 ;and store the amended char 29 SUBS R1, R1, #1 ;decrement the character count 20 BNE MainLoop ADDMI Increment parity counter if MSB is hi Strings p. 14/16
47 Program: setparity.s (Revised) TST 14 MainLoop 15 LDRB R2, [R0], #1 ;load the first byte into R2 16 MOV R6, R2 ;keep a copy of the original char 17 MOV R2, R2, LSL #24 ;shift to deal with msb 18 MOV R3, #0 ;zero the bit counter 19 MOV R4, #7 ;init the shift counter ParLoop 22 MOVS R2, R2, LSL #1 ;shift MSB into Neg flag 23 ADDMI R3, R3, #1 ;inc bit count if MSB is set 24 SUBS R4, R4, #1 ;update shift count 25 BNE ParLoop ;loop if still bits to check 26 TST R3, #1 ;is the parity even 27 ORRNE R6, R6, #0x80 ;set the parity bit if odd 28 STRB R6, [R5], #1 ;and store the amended char 29 SUBS R1, R1, #1 ;decrement the character count 20 BNE MainLoop Is the parity even test LSBit Strings p. 14/16
48 Program: cstrcmp.s 11 LDR R2, Match ;assume strings not equal set to LDR R3, [R0], #4 ;store the first string length in R3 13 LDR R4, [R1], #4 ;store the second string length in R4 14 CMP R3, R4 15 BNE Done ;if they are different lengths, 17 CMP R3, #0 ;test for zero length if both are 18 BEQ Same ;zero length, nothing else to do 21 Loop 22 LDRB R5, [R0], #1 ;character of first string 23 LDRB R6, [R1], #1 ;character of second string 24 CMP R5, R6 ;are they the same 25 BNE Done ;if not the strings are different 26 SUBS R3, R3, #1 ;use the string length as a counter 27 BEQ Same ;if we got to the end of the count 28 ;the strings are the same 29 BAL Loop ;not done, loop 31 Same MOV R2, #0 ;clear the -1 from match (0 = match) 32 Done STR R2, Match ;store the result Strings p. 15/16
49 LDR Program: cstrcmp.s 11 LDR R2, Match ;assume strings not equal set to LDR R3, [R0], #4 ;store the first string length in R3 13 LDR R4, [R1], #4 ;store the second string length in R4 14 CMP R3, R4 15 BNE Done ;if they are different lengths, 17 CMP R3, #0 ;test for zero length if both are 18 BEQ Same ;zero length, nothing else to do 21 Loop 22 LDRB R5, [R0], #1 ;character of first string 23 LDRB R6, [R1], #1 ;character of second string 24 CMP R5, R6 ;are they the same 25 BNE Done ;if not the strings are different 26 SUBS R3, R3, #1 ;use the string length as a counter 27 BEQ Same ;if we got to the end of the count 28 ;the strings are the same 29 BAL Loop ;not done, loop 31 Same MOV R2, #0 ;clear the -1 from match (0 = match) 32 Done STR R2, Match ;store the result Assume result is false Strings p. 15/16
50 Program: cstrcmp.s 11 LDR R2, Match ;assume strings not equal set to LDR R3, [R0], #4 ;store the first string length in R3 13 LDR R4, [R1], #4 ;store the second string length in R4 14 CMP R3, R4 15 BNE Done ;if they are different lengths, 17 CMP R3, #0 ;test for zero length if both are 18 BEQ Same ;zero length, nothing else to do 21 Loop 22 LDRB R5, [R0], #1 ;character of first string 23 LDRB R6, [R1], #1 ;character of second string 24 CMP R5, R6 ;are they the same 25 BNE Done ;if not the strings are different 26 SUBS R3, R3, #1 ;use the string length as a counter 27 BEQ Same ;if we got to the end of the count 28 ;the strings are the same 29 BAL Loop ;not done, loop 31 Same MOV R2, #0 ;clear the -1 from match (0 = match) 32 Done STR R2, Match ;store the result #4 We are using counted strings with a 4-byte count Strings p. 15/16
51 BNE Program: cstrcmp.s 11 LDR R2, Match ;assume strings not equal set to LDR R3, [R0], #4 ;store the first string length in R3 13 LDR R4, [R1], #4 ;store the second string length in R4 14 CMP R3, R4 15 BNE Done ;if they are different lengths, 17 CMP R3, #0 ;test for zero length if both are 18 BEQ Same ;zero length, nothing else to do 21 Loop 22 LDRB R5, [R0], #1 ;character of first string 23 LDRB R6, [R1], #1 ;character of second string 24 CMP R5, R6 ;are they the same 25 BNE Done ;if not the strings are different 26 SUBS R3, R3, #1 ;use the string length as a counter 27 BEQ Same ;if we got to the end of the count 28 ;the strings are the same 29 BAL Loop ;not done, loop 31 Same MOV R2, #0 ;clear the -1 from match (0 = match) 32 Done STR R2, Match ;store the result Abort if string lengths differ Strings p. 15/16
52 BEQ Program: cstrcmp.s 11 LDR R2, Match ;assume strings not equal set to LDR R3, [R0], #4 ;store the first string length in R3 13 LDR R4, [R1], #4 ;store the second string length in R4 14 CMP R3, R4 15 BNE Done ;if they are different lengths, 17 CMP R3, #0 ;test for zero length if both are 18 BEQ Same ;zero length, nothing else to do 21 Loop 22 LDRB R5, [R0], #1 ;character of first string 23 LDRB R6, [R1], #1 ;character of second string 24 CMP R5, R6 ;are they the same 25 BNE Done ;if not the strings are different 26 SUBS R3, R3, #1 ;use the string length as a counter 27 BEQ Same ;if we got to the end of the count 28 ;the strings are the same 29 BAL Loop ;not done, loop 31 Same MOV R2, #0 ;clear the -1 from match (0 = match) 32 Done STR R2, Match ;store the result Abort if no string to compare Strings p. 15/16
53 Program: cstrcmp.s 11 LDR R2, Match ;assume strings not equal set to LDR R3, [R0], #4 ;store the first string length in R3 13 LDR R4, [R1], #4 ;store the second string length in R4 14 CMP R3, R4 15 BNE Done ;if they are different lengths, 17 CMP R3, #0 ;test for zero length if both are 18 BEQ Same ;zero length, nothing else to do 21 Loop 22 LDRB R5, [R0], #1 ;character of first string 23 LDRB R6, [R1], #1 ;character of second string 24 CMP R5, R6 ;are they the same 25 BNE Done ;if not the strings are different 26 SUBS R3, R3, #1 ;use the string length as a counter 27 BEQ Same ;if we got to the end of the count 28 ;the strings are the same 29 BAL Loop ;not done, loop 31 Same MOV R2, #0 ;clear the -1 from match (0 = match) 32 Done STR R2, Match ;store the result BNE Exit on first difference found Strings p. 15/16
54 Program: cstrcmp.s 11 LDR R2, Match ;assume strings not equal set to LDR R3, [R0], #4 ;store the first string length in R3 13 LDR R4, [R1], #4 ;store the second string length in R4 14 CMP R3, R4 15 BNE Done ;if they are different lengths, 17 CMP R3, #0 ;test for zero length if both are 18 BEQ Same ;zero length, nothing else to do 21 Loop 22 LDRB R5, [R0], #1 ;character of first string 23 LDRB R6, [R1], #1 ;character of second string 24 CMP R5, R6 ;are they the same 25 BNE Done ;if not the strings are different 26 SUBS R3, R3, #1 ;use the string length as a counter 27 BEQ Same ;if we got to the end of the count 28 ;the strings are the same 29 BAL Loop ;not done, loop 31 Same MOV R2, #0 ;clear the -1 from match (0 = match) 32 Done STR R2, Match ;store the result Number of registers used: R0, R1, R2, R3, R4, R5, R6 Strings p. 15/16
55 Program: strcmp.s 9 LDR R0, =Data1 ;load the address of the lookup table 10 LDR R1, =Data2 11 LDR R2, Match ;assume strings not equal, set to MOV R3, #0 ;init register 13 MOV R4, #0 14 Count1 15 LDRB R5, [R0], #1 ;load the first byte into R5 16 CMP R5, #0 ;is it the terminator 17 BEQ Count2 ;if not, Loop 18 ADD R3, R3, #1 ;increment count 19 BAL Count1 20 Count2 21 LDRB R5, [R1], #1 ;load the first byte into R5 22 CMP R5, #0 ;is it the terminator 23 BEQ Next ;if not, Loop 24 ADD R4, R4, #1 ;increment count 25 BAL Count2 Strings p. 16/16
56 LDR Program: strcmp.s 9 LDR R0, =Data1 ;load the address of the lookup table 10 LDR R1, =Data2 11 LDR R2, Match ;assume strings not equal, set to MOV R3, #0 ;init register 13 MOV R4, #0 14 Count1 15 LDRB R5, [R0], #1 ;load the first byte into R5 16 CMP R5, #0 ;is it the terminator 17 BEQ Count2 ;if not, Loop 18 ADD R3, R3, #1 ;increment count 19 BAL Count1 20 Count2 21 LDRB R5, [R1], #1 ;load the first byte into R5 22 CMP R5, #0 ;is it the terminator 23 BEQ Next ;if not, Loop 24 ADD R4, R4, #1 ;increment count 25 BAL Count2 Assume result is false Strings p. 16/16
57 Program: strcmp.s 9 LDR R0, =Data1 ;load the address of the lookup table 10 LDR R1, =Data2 11 LDR R2, Match ;assume strings not equal, set to MOV R3, #0 ;init register 13 MOV R4, #0 14 Count1 15 LDRB R5, [R0], #1 ;load the first byte into R5 16 CMP R5, #0 ;is it the terminator 17 BEQ Count2 ;if not, Loop 18 ADD R3, R3, #1 ;increment count 19 BAL Count1 20 Count2 21 LDRB R5, [R1], #1 ;load the first byte into R5 22 CMP R5, #0 ;is it the terminator 23 BEQ Next ;if not, Loop 24 ADD R4, R4, #1 ;increment count 25 BAL Count2 strlen(table1) Calculate length of first string Strings p. 16/16
58 Program: strcmp.s 9 LDR R0, =Data1 ;load the address of the lookup table 10 LDR R1, =Data2 11 LDR R2, Match ;assume strings not equal, set to MOV R3, #0 ;init register 13 MOV R4, #0 14 Count1 15 LDRB R5, [R0], #1 ;load the first byte into R5 16 CMP R5, #0 ;is it the terminator 17 BEQ Count2 ;if not, Loop 18 ADD R3, R3, #1 ;increment count 19 BAL Count1 20 Count2 21 LDRB R5, [R1], #1 ;load the first byte into R5 22 CMP R5, #0 ;is it the terminator 23 BEQ Next ;if not, Loop 24 ADD R4, R4, #1 ;increment count 25 BAL Count2 strlen(table2) Calculate length of second string Strings p. 16/16
59 Program: strcmp.s 9 LDR R0, =Data1 ;load the address of the lookup table 10 LDR R1, =Data2 11 LDR R2, Match ;assume strings not equal, set to MOV R3, #0 ;init register 13 MOV R4, #0 14 Count1 15 LDRB R5, [R0], #1 ;load the first byte into R5 16 CMP R5, #0 ;is it the terminator 17 BEQ Count2 ;if not, Loop 18 ADD R3, R3, #1 ;increment count 19 BAL Count1 20 Count2 21 LDRB R5, [R1], #1 ;load the first byte into R5 22 CMP R5, #0 ;is it the terminator 23 BEQ Next ;if not, Loop 24 ADD R4, R4, #1 ;increment count 25 BAL Count2 BEQ/ADD Conditional Execution: ADDNE Rx, Rx, #1 ; inc string length Strings p. 16/16
60 Program: strcmp.s 9 LDR R0, =Data1 ;load the address of the lookup table 10 LDR R1, =Data2 11 LDR R2, Match ;assume strings not equal, set to MOV R3, #0 ;init register 13 MOV R4, #0 14 Count1 15 LDRB R5, [R0], #1 ;load the first byte into R5 16 CMP R5, #0 ;is it the terminator 17 BEQ Count2 ;if not, Loop 18 ADD R3, R3, #1 ;increment count 19 BAL Count1 20 Count2 21 LDRB R5, [R1], #1 ;load the first byte into R5 22 CMP R5, #0 ;is it the terminator 23 BEQ Next ;if not, Loop 24 ADD R4, R4, #1 ;increment count 25 BAL Count2 Compared to two LDR instructions in cstrcmp.s Strings p. 16/16
61 Program: strcmp.s 9 LDR R0, =Data1 ;load the address of the lookup table 10 LDR R1, =Data2 11 LDR R2, Match ;assume strings not equal, set to MOV R3, #0 ;init register 13 MOV R4, #0 14 Count1 15 LDRB R5, [R0], #1 ;load the first byte into R5 16 CMP R5, #0 ;is it the terminator 17 BEQ Count2 ;if not, Loop 18 ADD R3, R3, #1 ;increment count 19 BAL Count1 20 Count2 21 LDRB R5, [R1], #1 ;load the first byte into R5 22 CMP R5, #0 ;is it the terminator 23 BEQ Next ;if not, Loop 24 ADD R4, R4, #1 ;increment count 25 BAL Count2! Counted strings are easier to work with! Strings p. 16/16
THUMB Instruction Set
5 THUMB Instruction Set This chapter describes the THUMB instruction set. Format Summary 5-2 Opcode Summary 5-3 5. Format : move shifted register 5-5 5.2 Format 2: add/subtract 5-7 5.3 Format 3: move/compare/add/subtract
An Introduction to Assembly Programming with the ARM 32-bit Processor Family
An Introduction to Assembly Programming with the ARM 32-bit Processor Family G. Agosta Politecnico di Milano December 3, 2011 Contents 1 Introduction 1 1.1 Prerequisites............................. 2
The ARM Architecture. With a focus on v7a and Cortex-A8
The ARM Architecture With a focus on v7a and Cortex-A8 1 Agenda Introduction to ARM Ltd ARM Processors Overview ARM v7a Architecture/Programmers Model Cortex-A8 Memory Management Cortex-A8 Pipeline 2 ARM
EE282 Computer Architecture and Organization Midterm Exam February 13, 2001. (Total Time = 120 minutes, Total Points = 100)
EE282 Computer Architecture and Organization Midterm Exam February 13, 2001 (Total Time = 120 minutes, Total Points = 100) Name: (please print) Wolfe - Solution In recognition of and in the spirit of the
The stack and the stack pointer
The stack and the stack pointer If you google the word stack, one of the definitions you will get is: A reserved area of memory used to keep track of a program's internal operations, including functions,
ARM Instruction Set. ARM7TDMI-S Data Sheet. Final - Open Access
4 ARM Instruction Set This chapter describes the ARM instruction set. 4.1 Instruction Set Summary 4-2 4.2 The Condition Field 4-5 4.3 Branch and Exchange (BX) 4-6 4.4 Branch and Branch with Link (B, BL)
Java Interview Questions and Answers
1. What is the most important feature of Java? Java is a platform independent language. 2. What do you mean by platform independence? Platform independence means that we can write and compile the java
Number Representation
Number Representation CS10001: Programming & Data Structures Pallab Dasgupta Professor, Dept. of Computer Sc. & Engg., Indian Institute of Technology Kharagpur Topics to be Discussed How are numeric data
ASSEMBLY LANGUAGE PROGRAMMING (6800) (R. Horvath, Introduction to Microprocessors, Chapter 6)
ASSEMBLY LANGUAGE PROGRAMMING (6800) (R. Horvath, Introduction to Microprocessors, Chapter 6) 1 COMPUTER LANGUAGES In order for a computer to be able to execute a program, the program must first be present
ESCI 386 IDL Programming for Advanced Earth Science Applications Lesson 6 Program Control
ESCI 386 IDL Programming for Advanced Earth Science Applications Lesson 6 Program Control Reading: Bowman, Chapters 16 CODE BLOCKS A code block consists of several lines of code contained between a BEGIN
HC12 Assembly Language Programming
HC12 Assembly Language Programming Programming Model Addressing Modes Assembler Directives HC12 Instructions Flow Charts 1 Assembler Directives In order to write an assembly language program it is necessary
Stacks. Linear data structures
Stacks Linear data structures Collection of components that can be arranged as a straight line Data structure grows or shrinks as we add or remove objects ADTs provide an abstract layer for various operations
Software based Finite State Machine (FSM) with general purpose processors
Software based Finite State Machine (FSM) with general purpose processors White paper Joseph Yiu January 2013 Overview Finite state machines (FSM) are commonly used in electronic designs. FSM can be used
9 Control Statements. 9.1 Introduction. 9.2 Objectives. 9.3 Statements
9 Control Statements 9.1 Introduction The normal flow of execution in a high level language is sequential, i.e., each statement is executed in the order of its appearance in the program. However, depending
Faculty of Engineering Student Number:
Philadelphia University Student Name: Faculty of Engineering Student Number: Dept. of Computer Engineering Final Exam, First Semester: 2012/2013 Course Title: Microprocessors Date: 17/01//2013 Course No:
Systems I: Computer Organization and Architecture
Systems I: Computer Organization and Architecture Lecture 2: Number Systems and Arithmetic Number Systems - Base The number system that we use is base : 734 = + 7 + 3 + 4 = x + 7x + 3x + 4x = x 3 + 7x
Chapter 7 Assembly Language
Chapter 7 Assembly Language Human-Readable Machine Language Computers like ones and zeros 0001110010000110 Humans like symbols ADD R6,R2,R6 increment index reg. Assembler is a program that turns symbols
Graded ARM assembly language Examples
Graded ARM assembly language Examples These examples have been created to help students with the basics of Keil s ARM development system. I am providing a series of examples that demonstrate the ARM s
Keil C51 Cross Compiler
Keil C51 Cross Compiler ANSI C Compiler Generates fast compact code for the 8051 and it s derivatives Advantages of C over Assembler Do not need to know the microcontroller instruction set Register allocation
How To Write An Array In A Microsoft Zil
Array Declaration and Storage Allocation The first step is to reserve sufficient space for the array: 1.data list:.space 1000 # reserves a block of 1000 bytes This yields a contiguous block of bytes of
Character Translation Methods
Supplement to: Irvine, Kip R. Assembly Language for Intel-Based Computers, 4th Edition. This file may be duplicated or printed for classroom use, as long as the author name, book title, and copyright notice
Typy danych. Data types: Literals:
Lab 10 MIPS32 Typy danych Data types: Instructions are all 32 bits byte(8 bits), halfword (2 bytes), word (4 bytes) a character requires 1 byte of storage an integer requires 1 word (4 bytes) of storage
Exceptions in MIPS. know the exception mechanism in MIPS be able to write a simple exception handler for a MIPS machine
7 Objectives After completing this lab you will: know the exception mechanism in MIPS be able to write a simple exception handler for a MIPS machine Introduction Branches and jumps provide ways to change
U:\montages\dominique\servo\moteur_AV_AR\program\moteur_AV_AR.asm jeudi 28 avril 2011 10:32
Norton Junior Moteur PWM AV - AR pour SLE BRESSUIRE PORTA ------------------------------------------------------- 0 = Entrée Servo 1 = PWM moteur 2 = Strap mode 3 = 4 = 5 = Relay AV - AR $Include 'C:\pemicro\ics08qtqyz\qtqy_registers.inc'
Developer Suite ARM. Assembler Guide. Version 1.2. Copyright 2000, 2001 ARM Limited. All rights reserved. ARM DUI 0068B
ARM Developer Suite Version 1.2 Assembler Guide Copyright 2000, 2001 ARM Limited. All rights reserved. ARM DUI 0068B ARM Developer Suite Assembler Guide Copyright 2000, 2001 ARM Limited. All rights reserved.
M6800. Assembly Language Programming
M6800 Assembly Language Programming 1 3. MC6802 MICROPROCESSOR MC6802 microprocessor runs in 1MHz clock cycle. It has 64 Kbyte memory address capacity using 16-bit addressing path (A0-A15). The 8-bit data
Test Driven Development in Assembler a little story about growing software from nothing
Test Driven Development in Assembler a little story about growing software from nothing Olve Maudal During the last decade Test-Driven Development has become an established practice for developing software
Translating C code to MIPS
Translating C code to MIPS why do it C is relatively simple, close to the machine C can act as pseudocode for assembler program gives some insight into what compiler needs to do what's under the hood do
Instruction Set Architecture. or How to talk to computers if you aren t in Star Trek
Instruction Set Architecture or How to talk to computers if you aren t in Star Trek The Instruction Set Architecture Application Compiler Instr. Set Proc. Operating System I/O system Instruction Set Architecture
Introduction to Java
Introduction to Java The HelloWorld program Primitive data types Assignment and arithmetic operations User input Conditional statements Looping Arrays CSA0011 Matthew Xuereb 2008 1 Java Overview A high
Instruction Set Architecture
Instruction Set Architecture Consider x := y+z. (x, y, z are memory variables) 1-address instructions 2-address instructions LOAD y (r :=y) ADD y,z (y := y+z) ADD z (r:=r+z) MOVE x,y (x := y) STORE x (x:=r)
Pemrograman Dasar. Basic Elements Of Java
Pemrograman Dasar Basic Elements Of Java Compiling and Running a Java Application 2 Portable Java Application 3 Java Platform Platform: hardware or software environment in which a program runs. Oracle
Apple II Technical Notes
#1: Interrupt Environment with the Revised by: Matt Deatherage November 1988 Revised by: Rilla Reynolds November 1985 This Technical Note describes the interrupt environment one should take into account
ND48-RS ASCII A2.04 Communication Protocol
ND48-RS ASCII A2.04 Communication Protocol SEM 06.2003 Str. 1/6 ND48-RS ASCII A2.04 Communication Protocol ASCII A2.04 protocol provides serial communication with most of the measurement and control devices
Virtual Integrated Design Getting started with RS232 Hex Com Tool v6.0
Virtual Integrated Design Getting started with RS232 Hex Com Tool v6.0 Copyright, 1999-2007 Virtual Integrated Design, All rights reserved. 1 Contents: 1. The Main Window. 2. The Port Setup Window. 3.
An Introduction to the ARM 7 Architecture
An Introduction to the ARM 7 Architecture Trevor Martin CEng, MIEE Technical Director This article gives an overview of the ARM 7 architecture and a description of its major features for a developer new
Efficient Low-Level Software Development for the i.mx Platform
Freescale Semiconductor Application Note Document Number: AN3884 Rev. 0, 07/2009 Efficient Low-Level Software Development for the i.mx Platform by Multimedia Applications Division Freescale Semiconductor,
ios applications reverse engineering Julien Bachmann julien@scrt.ch
ios applications reverse engineering 1 Julien Bachmann julien@scrt.ch Agenda Motivations The architecture Mach-O Objective-C ARM AppStore binaries Find'em Decrypt'em Reverse'em What to look for Where to
StrongARM** SA-110 Microprocessor Instruction Timing
StrongARM** SA-110 Microprocessor Instruction Timing Application Note September 1998 Order Number: 278194-001 Information in this document is provided in connection with Intel products. No license, express
plc numbers - 13.1 Encoded values; BCD and ASCII Error detection; parity, gray code and checksums
plc numbers - 3. Topics: Number bases; binary, octal, decimal, hexadecimal Binary calculations; s compliments, addition, subtraction and Boolean operations Encoded values; BCD and ASCII Error detection;
The string of digits 101101 in the binary number system represents the quantity
Data Representation Section 3.1 Data Types Registers contain either data or control information Control information is a bit or group of bits used to specify the sequence of command signals needed for
Informatica e Sistemi in Tempo Reale
Informatica e Sistemi in Tempo Reale Introduction to C programming Giuseppe Lipari http://retis.sssup.it/~lipari Scuola Superiore Sant Anna Pisa October 25, 2010 G. Lipari (Scuola Superiore Sant Anna)
ASCII Encoding. The char Type. Manipulating Characters. Manipulating Characters
The char Type ASCII Encoding The C char type stores small integers. It is usually 8 bits. char variables guaranteed to be able to hold integers 0.. +127. char variables mostly used to store characters
ARM: Assembly Language Programming
School of Design, Engineering & Computing BSc (Hons) Computing BSc (Hons) Software Engineering Management ARM: Assembly Language Programming Stephen Welsh Peter Knaggs December 22, 2003 Contents Contents
Bachelors of Computer Application Programming Principle & Algorithm (BCA-S102T)
Unit- I Introduction to c Language: C is a general-purpose computer programming language developed between 1969 and 1973 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating
How It All Works. Other M68000 Updates. Basic Control Signals. Basic Control Signals
CPU Architectures Motorola 68000 Several CPU architectures exist currently: Motorola Intel AMD (Advanced Micro Devices) PowerPC Pick one to study; others will be variations on this. Arbitrary pick: Motorola
The AVR Microcontroller and C Compiler Co-Design Dr. Gaute Myklebust ATMEL Corporation ATMEL Development Center, Trondheim, Norway
The AVR Microcontroller and C Compiler Co-Design Dr. Gaute Myklebust ATMEL Corporation ATMEL Development Center, Trondheim, Norway Abstract High Level Languages (HLLs) are rapidly becoming the standard
MACHINE ARCHITECTURE & LANGUAGE
in the name of God the compassionate, the merciful notes on MACHINE ARCHITECTURE & LANGUAGE compiled by Jumong Chap. 9 Microprocessor Fundamentals A system designer should consider a microprocessor-based
Sources: On the Web: Slides will be available on:
C programming Introduction The basics of algorithms Structure of a C code, compilation step Constant, variable type, variable scope Expression and operators: assignment, arithmetic operators, comparison,
Modicon Modbus Protocol Reference Guide. PI MBUS 300 Rev. J
Modicon Modbus Protocol Reference Guide PI MBUS 300 Rev. J 1 Modicon Modbus Protocol Reference Guide PI MBUS 300 Rev. J June 1996 MODICON, Inc., Industrial Automation Systems One High Street North Andover,
RS-485 Protocol Manual
RS-485 Protocol Manual Revision: 1.0 January 11, 2000 RS-485 Protocol Guidelines and Description Page i Table of Contents 1.0 COMMUNICATIONS BUS OVERVIEW... 1 2.0 DESIGN GUIDELINES... 1 2.1 Hardware Design
OPERATOR INTERFACE PRODUCTS APPLICATION NOTE. Xycom 4800/2000 OIL (Operator Interface Language)- Series Terminals: Backup and Restore with ProComm
Page 1 of 9 Xycom 4800/2000 OIL (Operator Interface Language)- Series Terminals: Backup and Restore with ProComm Introduction The Xycom 4800/2000 OIL-series terminals offer you the ability to backup and
Introduction to MIPS Assembly Programming
1 / 26 Introduction to MIPS Assembly Programming January 23 25, 2013 2 / 26 Outline Overview of assembly programming MARS tutorial MIPS assembly syntax Role of pseudocode Some simple instructions Integer
Chapter 7D The Java Virtual Machine
This sub chapter discusses another architecture, that of the JVM (Java Virtual Machine). In general, a VM (Virtual Machine) is a hypothetical machine (implemented in either hardware or software) that directly
Operating Systems. Virtual Memory
Operating Systems Virtual Memory Virtual Memory Topics. Memory Hierarchy. Why Virtual Memory. Virtual Memory Issues. Virtual Memory Solutions. Locality of Reference. Virtual Memory with Segmentation. Page
A single register, called the accumulator, stores the. operand before the operation, and stores the result. Add y # add y from memory to the acc
Other architectures Example. Accumulator-based machines A single register, called the accumulator, stores the operand before the operation, and stores the result after the operation. Load x # into acc
AN2183. Using FLASH as EEPROM on the MC68HC908GP32. Introduction. Semiconductor Products Sector Application Note
Order this document by /D Semiconductor Products Sector Application Note Using FLASH as EEPROM on the MC68HC908GP32 By Derrick H.J. Klotz Field Applications Engineer Toronto, Canada Introduction This application
Modbus Protocol. PDF format version of the MODBUS Protocol. http://www.http://www.modicon.com/techpubs/toc7.html. The original was found at:
Modbus Protocol PDF format version of the MODBUS Protocol The original was found at: http://www.http://www.modicon.com/techpubs/toc7.html (In case of any discrepancies, that version should be considered
MACHINE INSTRUCTIONS AND PROGRAMS
CHAPTER 2 MACHINE INSTRUCTIONS AND PROGRAMS CHAPTER OBJECTIVES In this chapter you will learn about: Machine instructions and program execution, including branching and subroutine call and return operations
4D Plugin SDK v11. Another minor change, real values on 10 bytes is no longer supported.
4D Plugin SDK v11 4D Plugin API 4D Plugin API v11 is a major upgrade of 4D Plugin API. The two major modifications are that it is now fully Unicode compliant, and that it gives support to the new 4D pictures.
8051 Serial Port. Crystal TXD. I/O Device RXD. Embedded Systems 1 5-1 8051 Peripherals
8051 Serial Port The 8051 contains a UART Universal Asynchronous Receiver Transmitter The serial port is full-duplex It can transmit and receive simultaneously 2 Port 3 pins are used to provide the serial
MIPS Assembly Code Layout
Learning MIPS & SPIM MIPS assembly is a low-level programming language The best way to learn any programming language is to write code We will get you started by going through a few example programs and
ARM Cortex-M3 Assembly Language
ARM Cortex-M3 Assembly Language When a high level language compiler processes source code, it generates the assembly language translation of all of the high level code into a processor s specific set of
Nemo 96HD/HD+ MODBUS
18/12/12 Pagina 1 di 28 MULTIFUNCTION FIRMWARE 2.30 Nemo 96HD/HD+ MODBUS COMMUNICATION PROTOCOL CONTENTS 1.0 ABSTRACT 2.0 DATA MESSAGE DESCRIPTION 2.1 Parameters description 2.2 Data format 2.3 Description
A-level COMPUTER SCIENCE
A-level COMPUTER SCIENCE Paper 2 TBC am/pm 2 hours 30 minutes Materials There are no additional materials required for this paper. Instructions Use black ink or black ball-point pen. Fill in the boxes
Chapter 2 Topics. 2.1 Classification of Computers & Instructions 2.2 Classes of Instruction Sets 2.3 Informal Description of Simple RISC Computer, SRC
Chapter 2 Topics 2.1 Classification of Computers & Instructions 2.2 Classes of Instruction Sets 2.3 Informal Description of Simple RISC Computer, SRC See Appendix C for Assembly language information. 2.4
Summary of the MARIE Assembly Language
Supplement for Assignment # (sections.8 -. of the textbook) Summary of the MARIE Assembly Language Type of Instructions Arithmetic Data Transfer I/O Branch Subroutine call and return Mnemonic ADD X SUBT
Jorix kernel: real-time scheduling
Jorix kernel: real-time scheduling Joris Huizer Kwie Min Wong May 16, 2007 1 Introduction As a specialized part of the kernel, we implemented two real-time scheduling algorithms: RM (rate monotonic) and
Member Functions of the istream Class
Member Functions of the istream Class The extraction operator is of limited use because it always uses whitespace to delimit its reads of the input stream. It cannot be used to read those whitespace characters,
PROBLEMS (Cap. 4 - Istruzioni macchina)
98 CHAPTER 2 MACHINE INSTRUCTIONS AND PROGRAMS PROBLEMS (Cap. 4 - Istruzioni macchina) 2.1 Represent the decimal values 5, 2, 14, 10, 26, 19, 51, and 43, as signed, 7-bit numbers in the following binary
Boolean Expressions, Conditions, Loops, and Enumerations. Precedence Rules (from highest to lowest priority)
Boolean Expressions, Conditions, Loops, and Enumerations Relational Operators == // true if two values are equivalent!= // true if two values are not equivalent < // true if left value is less than the
5 Arrays and Pointers
5 Arrays and Pointers 5.1 One-dimensional arrays Arrays offer a convenient way to store and access blocks of data. Think of arrays as a sequential list that offers indexed access. For example, a list of
Application Note 195. ARM11 performance monitor unit. Document number: ARM DAI 195B Issued: 15th February, 2008 Copyright ARM Limited 2007
Application Note 195 ARM11 performance monitor unit Document number: ARM DAI 195B Issued: 15th February, 2008 Copyright ARM Limited 2007 Copyright 2007 ARM Limited. All rights reserved. Application Note
M A S S A C H U S E T T S I N S T I T U T E O F T E C H N O L O G Y DEPARTMENT OF ELECTRICAL ENGINEERING AND COMPUTER SCIENCE
M A S S A C H U S E T T S I N S T I T U T E O F T E C H N O L O G Y DEPARTMENT OF ELECTRICAL ENGINEERING AND COMPUTER SCIENCE 1. Introduction 6.004 Computation Structures β Documentation This handout is
System Calls Related to File Manipulation
KING FAHD UNIVERSITY OF PETROLEUM AND MINERALS Information and Computer Science Department ICS 431 Operating Systems Lab # 12 System Calls Related to File Manipulation Objective: In this lab we will be
The Little Man Computer
The Little Man Computer The Little Man Computer - an instructional model of von Neuman computer architecture John von Neuman (1903-1957) and Alan Turing (1912-1954) each independently laid foundation for
The programming language C. sws1 1
The programming language C sws1 1 The programming language C invented by Dennis Ritchie in early 1970s who used it to write the first Hello World program C was used to write UNIX Standardised as K&C (Kernighan
PROBLEMS #20,R0,R1 #$3A,R2,R4
506 CHAPTER 8 PIPELINING (Corrisponde al cap. 11 - Introduzione al pipelining) PROBLEMS 8.1 Consider the following sequence of instructions Mul And #20,R0,R1 #3,R2,R3 #$3A,R2,R4 R0,R2,R5 In all instructions,
ARM7TDMI-S. Technical Reference Manual. (Rev 3) Copyright ARM Limited 1998-2000. All rights reserved. ARM DDI 0084F
ARM7TDMI-S (Rev 3) Technical Reference Manual Copyright ARM Limited 1998-2000. All rights reserved. ARM DDI 0084F ARM7TDMI-S Technical Reference Manual Copyright ARM Limited 1998-2000. All rights reserved.
6. Control Structures
- 35 - Control Structures: 6. Control Structures A program is usually not limited to a linear sequence of instructions. During its process it may bifurcate, repeat code or take decisions. For that purpose,
CS 141: Introduction to (Java) Programming: Exam 1 Jenny Orr Willamette University Fall 2013
Oct 4, 2013, p 1 Name: CS 141: Introduction to (Java) Programming: Exam 1 Jenny Orr Willamette University Fall 2013 1. (max 18) 4. (max 16) 2. (max 12) 5. (max 12) 3. (max 24) 6. (max 18) Total: (max 100)
Technical Data Sheet UM-005. UM005-doc-01.04 In reference to UM005-c-01.04
Technical Data Sheet UM-005 UM005-doc-01.04 In reference to UM005-c-01.04 Contents Contents... 2 Introductions... 3 Specifications... 3 Pin description... 4 Connection diagram... 4 Module PCB dimensions...
X86-64 Architecture Guide
X86-64 Architecture Guide For the code-generation project, we shall expose you to a simplified version of the x86-64 platform. Example Consider the following Decaf program: class Program { int foo(int
Exception and Interrupt Handling in ARM
Exception and Interrupt Handling in ARM Architectures and Design Methods for Embedded Systems Summer Semester 2006 Author: Ahmed Fathy Mohammed Abdelrazek Advisor: Dominik Lücke Abstract We discuss exceptions
Python Lists and Loops
WEEK THREE Python Lists and Loops You ve made it to Week 3, well done! Most programs need to keep track of a list (or collection) of things (e.g. names) at one time or another, and this week we ll show
Illustration 1: Diagram of program function and data flow
The contract called for creation of a random access database of plumbing shops within the near perimeter of FIU Engineering school. The database features a rating number from 1-10 to offer a guideline
MICROPROCESSOR. Exclusive for IACE Students www.iace.co.in iacehyd.blogspot.in Ph: 9700077455/422 Page 1
MICROPROCESSOR A microprocessor incorporates the functions of a computer s central processing unit (CPU) on a single Integrated (IC), or at most a few integrated circuit. It is a multipurpose, programmable
JavaScript: Control Statements I
1 7 JavaScript: Control Statements I 7.1 Introduction 2 The techniques you will learn here are applicable to most high-level languages, including JavaScript 1 7.2 Algorithms 3 Any computable problem can
Experiment 4: Interfacing to Input/Output Devices
Experiment 4: Interfacing to Input/Output Devices This experiment further consolidates the programmer s view of computer architecture. It does this by showing you how microprocessors interface to the real
Parameter Passing. Standard mechanisms. Call by value-result Call by name, result
Parameter Passing Standard mechanisms Call by value Call by reference Other methods Call by value-result Call by name, result Terms Function definition where the details of the function are presented (type,
Binary Representation. Number Systems. Base 10, Base 2, Base 16. Positional Notation. Conversion of Any Base to Decimal.
Binary Representation The basis of all digital data is binary representation. Binary - means two 1, 0 True, False Hot, Cold On, Off We must be able to handle more than just values for real world problems
A Choices Hypervisor on the ARM architecture
A Choices Hypervisor on the ARM architecture Rishi Bhardwaj, Phillip Reames, Russell Greenspan Vijay Srinivas Nori, Ercan Ucan ABSTRACT Choices is an object oriented operating system that runs on the x86
ENGINEERING COMMITTEE Digital Video Subcommittee SCTE 20 2012 METHODS FOR CARRIAGE OF CEA-608 CLOSED CAPTIONS AND NON-REAL TIME SAMPLED VIDEO
ENGINEERING COMMITTEE Digital Video Subcommittee SCTE 20 2012 METHODS FOR CARRIAGE OF CEA-608 CLOSED CAPTIONS AND NON-REAL TIME SAMPLED VIDEO NOTICE The Society of Cable Telecommunications Engineers (SCTE)
LC-3 Assembly Language
LC-3 Assembly Language Programming and tips Textbook Chapter 7 CMPE12 Summer 2008 Assembly and Assembler Machine language - binary Assembly language - symbolic 0001110010000110 An assembler is a program
Python Loops and String Manipulation
WEEK TWO Python Loops and String Manipulation Last week, we showed you some basic Python programming and gave you some intriguing problems to solve. But it is hard to do anything really exciting until
Numeral Systems. The number twenty-five can be represented in many ways: Decimal system (base 10): 25 Roman numerals:
Numeral Systems Which number is larger? 25 8 We need to distinguish between numbers and the symbols that represent them, called numerals. The number 25 is larger than 8, but the numeral 8 above is larger
8-bit RISC Microcontroller. Application Note. AVR236: CRC Check of Program Memory
AVR236: CRC Check of Program Memory Features CRC Generation and Checking of Program Memory Supports all AVR Controllers with LPM Instruction Compact Code Size, 44 Words (CRC Generation and CRC Checking)
Answers to Review Questions Chapter 7
Answers to Review Questions Chapter 7 1. The size declarator is used in a definition of an array to indicate the number of elements the array will have. A subscript is used to access a specific element