NET3001. Assembly Language

Size: px

Start display at page:

Download "NET3001. Assembly Language"

Lee Blair
6 years ago
Views:

1 NET3001 Assembly Language

2 Sample Program task: given the number of students in class, and the number of students absent, add them to determine the total number of students plan number of students is stored in RAM at location 0x the number of students absent is stored in RAM, at location 0x load the contents of 0x into r4 load the contents of 0x into r5 add the contents r5 to the r4 store the result r4 into address 0x

3 Sample Program.text.global main main: // we are creating program // visible outside the obj file // a label to the symbol table mov r7, #0x // this is a number which // we will use as a base address ldr r4,[r7] ldr r5,[r7,#4] add r4, r4, r5 // read 0x into r4 // read 0x into r5 // add str r4,[r7,#0x10] //store it into 0x

4 Things to note wouldn't it be easier if we could use names instead of long numbers like 0x we'll get to that in a few slide further on you can't just reference a memory address you must load the memory address into a register and reference the address through that register the term base address means that you have a memory address, and you add/subtract small numbers from that this enables you to reference lots of memory that is clustered around the base address and it means that the cluster can be located anywhere in RAM

5 Assembly Directives cpu instructions create a flow of instructions at the current location pointer assembler directives do not create code, but direct the assembler to set a new location pointer create spaces in the flow set data strings into the flow add labels to the symbol table

6 Sample Program in Machine Code <main>: 0: e3a07202 mov r7, # ; 0x : e ldr r4, [r7] 8: e ldr r5, [r7, #4] c: e add r4, r4, r5 10: e str r4, [r7, #16]

7 2 step assembly the system we are using creates a program in two steps assembler translates assembly instructions into binary opcodes linker does not finalize where to store them leaves the result in an object file binds one or more object files and assigns the code to specific addresses creates an executable file (or loadable) the other steps are loading and debugging

8 Cross Assembler In this course, we are using a cross assembler we are using a Pentium/x86 processor to prepare the code that will run on a Cortex processor Similarly, later in the course, we will be using a cross compiler

9 Assembly Directives.text Short form for.section.text.data the linker will put this at 0x , after vectors Short form for.section.data the linker will put this at 0x section.bss.section.vectors the linker will put this at 0x // /*.. */ These all inform the assembler about where the subsequent code/data is to go

10 Assembler Directives.byte d.word d.ascii string.asciz string.string string create bytes in the data stream NOTE: just like in C/C++, a single quote 'a' is just a single character(char), but a double quote a is a string (char[])

11 Assembler Directives.fill n,s,f fills n times s bytes with f (s=1,2 or 4).space n,f.skip n,f fill n bytes with f.org n moves ahead by n bytes

12 Assembler Directives.equ.set. add entries to the symbol table if you use the symbol. it means the current location counter this may come in hand in obscure situations

13 Labels Any word beginning in the left hand column and ending with a colon is a label this causes an entry in the symbol table the value of this symbol is the value of the current location counter.text main: mov r1, #0x600 mov r4, #0 loop1: mov r12, #5 < set location = 0x0000 < create label main < create label loop1 add r4, r12, r4.data < set location = 0x byte 14 < location is now 0x

14 Assembly Instructions: Direction in the ARM and Cortex, all instructions operate from right to left, except STR in other CPU's, this may be different i386 is often right to left, but not always mov eax, #45 in MSP430, instructions operate from left to right mov #123, r12

15 Assembly Instructions: Vocabulary in the ARM/Cortex data movement within the ALU is move data movement to RAM/FLASH/IO is load or store mem-to-mem move is not possible in other CPU's this may be different registers memory i386: move is from reg/mem to reg/mem in is from i/o to reg out is from reg to i/o Motorola load is from mem/io to reg (same as ARM) store is from reg to mem/io (same as ARM) transfer is from reg to reg move is from mem/io to mem/io in MSP430, all data movement is move mov store load!! no mem-to-mem move

16 Data Movement CPU store load data(32) addr(32) addr match Flash/Program move RAM/variables addr match addr other

17 Getting numbers into registers you can use a mov instruction to put a small bit pattern into a register mov r4,#12 mov r5,#0x3a but you can't use a mov for a complex pattern mov r7,#0x20001c44 // <----not allowed you have two choices: move it in chunks mov r7,#0x orr r7,r7,#0x1c00 // r7=0x20001c00 orr r7,r7,#0x44 // r7=0x20001c44 or you can put the number nearby to your code, and do a ldr and use the PC (r15) to fetch it ldr r7,=0x20001c44 turns into ldr r7,[r15,#some_distance_away]

18 A common idiom for addressing One of the first things we have to do on the Cortex is turn on the various parts of the chip...in C RCC->APB2ENR = 0x74A3D;// enable zones a-d of gpio // the left hand side is at address 0x but you can't use a mov for a complex pattern mov r7,#0x // <----not allowed Here's now it could be done: movw r7,#0x orr r7,r7,#0x orr r7,r7,#0x18 movw r6,#0x4a3d orr r6,r6,#0x str r6,[r7] I don't recommend this style have a look at the next slide... // r7=0x // r7=0x // r6=0x00074a3d

19 A common idiom (cont'd)...literal mode Another way to do the same task uses the '=' prefix RCC->APB2ENR = 0x74A3D;// enable zones a-d of gpio // the left hand side is at address 0x can turn into ldr r7,=0x ldr r6,=0x74a3d str r6,[r7] what the assembler does: // just add the = in front // remember this is a LDR ldr r7,[pc,#0x14] // reach ahead into flash ldr r6,[pc,#0x18] str r6,[r7] // a gap.word 0x // this area is called the pool.word 0x00074a3d oddly, this is slightly slower code, but takes the least amount of flash, and is much easier to understand

20 A common idiom (cont'd)...movt Another third way to do the same task uses MOVT RCC->APB2ENR = 0x74A3D;// enable zones a-d of gpio // the left hand side is at address 0x can turn into movw r7,#0x1018 movt r7,#0x4002 movw r6,#0x4a3d movt r6,#0x7 str r6,[r7] // fill in the bottom half // is move into top // again, the bottom half // move into top of r6 in fact, this is the fastest version, but not quite so easy to understand

21 Putting it all together.text // we are creating program.global main // visible outside the obj file main: // a label to the symbol table mov r7, #0x ldr r6, [r7] // read ram@0x into r6 ldr r5, [r7, #4] // read the next word into r5 add r6, r5, r6 // add them str r6, [r7, #0x10] // store into the destination

22 Again, including the data.text // we are creating program.global main // visible outside the obj file main: // a label to the symbol table mov r7,#0x ldr r6, [r7] // read ram@0x into r6 ldr r5, [r7,#4] // read the other one into r5 add r6, r5, r6 // add str r6, [r7,#0x10] // store into the destination.data.word 0x // memory at 0x word 0x434 // at 0x org 0x10 // skip ahead to 0x word 0 // empty space for the answer

23 Again, using labels.text.global main main: // we are creating program // visible outside the obj file // a label to the symbol table ldr r7,=nstudentsontime ldr r6,[r7] // r6 = nstudentsontime ldr r5,[r7,#4] // r5 = nlatecomers add r6, r5, r6 // r6 = r5 + r6 str r6,[r7,#0x10] // ntotalstudents = r6.data // change ptr to 0x nstudentsontime:.word 12 nlatecomers:.word 4.org 0x10 // skip ahead to 0x ntotalstudents:.fill 2

24 Symbol Table while the assembler is running, it collects all the symbols into a symbol table this is just a spreadsheet with columns for name value type size

25 From the example name value type size main 0x label 0 nstudentsontime 0x word 4 nlatecomers 0x word 4 ntotalstudents 0x word 4

26 Symbol Table The symbol table converts human-readable names into machine-usable numbers it's an aid to humans; done correctly, it makes your code much more readable nnumberstudents.word 31 In a similar way, an DSN server converts humanreadable domain names into IP addresses An similarly, the paper telephone book helps you convert human-readble names into machine-readable phone numbers Pat Beirne

27 Example 2 write a program to delay by 40,000 loops

28 Example 2 write a program to delay by 40,000 loops.text.global delay40k delay40k: movw r5,#40000 // start with r5 set s1: subs r5, r5, #1 // sub 1, set flags bne s1 // if we're not done, loop

29 Example 3 modify example 2 to take exactly 1msec.text.global delaymsec delaymsec: movw r5,#2667 //each loop takes.375usec s1: subs r5, r5, #1 // sub 1 bne s1 // if we're not done, loop

30 Example 4 delay loop, using global variable.text.global delaysome delaysome: ldr r7, =delaytime ldr r6, [r7] delaymsec: movw r5,#2667 // each loop takes 0.375usec s1: subs r5, r5, #1 // sub 1 bne s1 // if we're not done, loop subs r6, r6, #1 bne delaymsec.data delaytime:.word 5 // the msec to delay

31 Symbol Table Name Value Type delaysome x (maybe 0x ) label delaymsec x+6 label s1 x+10 label delaytime y (maybe 0x ) short the symbol table here shows how it might look after the assembler, but before the linker

32 Example 5 write a snippet which does a checksum on a string of bytes the address of the string is in a variable the string count is in a variable and the string data is in another variable put the checksum into a 4 th variable char* stringaddr = mystring; char csum = 0; for (i=stringcount; i>0; i--) { csum += *stringaddr; stringaddr++; }

33 Example 5.data mystring:.ascii // credit card stringcount:.word 16 csum:.byte 0.text.global calcchecksum.type calcchecksum,%function calcchecksum: ldr r11, =mystring ldr r10, =stringcount ldr r12,[r10] // go to ram to get length mov r6, #0 // this will accumulate cs1: ldrb r4,[r11] // fetch and add to csum add r6, r4 add r11, #1 // point to next char subs r12, #1 // decrement & test bne cs1 ldr r10, =csum // and save the answer strb r6, [r10]

34 Symbol Table Example 5 Name Value Type Size Content calcchecksum x label;func 0 n/a cs1 x+0x0c label 0 n/a mystring y byte[] stringcount y+0x10 word 4 16=0x10 csum y+0x14 byte 1 the answer this symbol table shows how it might look after the assembler the assembler builds the opcodes, but leaves empty spots where the operands will go; the linker fills in the blanks from the symbol table

35 Symbol Table Example 5 Name Value Type Size Content calcchecksum 0x label;func 0 n/a cs1 0x label 0 n/a mystring 0x byte[] stringcount 0x word 4 16=0x10 csum 0x byte 1 the answer the addresses above show how the symbol table might look after the linker has finished; this example assumes there is no other code/data in the project the address for calcchecksum will get changed to 0x when it use stored as a word; that's what the %function operator does; remember that we're in a Thumb environment, and any LDR to r15 must be an odd number

36 Instruction Take Time each instruction takes a certain number of CPU cycles the boards we will use operate at 8 million cycles per second register-to-register operations take 1 jumps take 2 loads and stores use 2 if you push or pop n registers, it takes n+1 cycles mov r3, r3 takes 1 ldr r7, [r3] takes 2 push {r4, r5, r6} takes 4

37 Binary Math shift left by 1 same as multiply by 2 shift left by 4 0x14 (20 10 ) << 1 0x28 (40 10 ) << multiply by 16 shift right by 1 0x14 (20 10 ) << 4 0x140 ( ) << divide by 2 if it ends with a 1, it's odd 0x14 (20 10 ) >> 1 0x0A (10 10 ) >> ,3,5,7,9,b,d,f 0x21 = 0b = if it start with a 1, it's negative 0xFFFF.FFD1 =

38 Binary Math 2's complement flip all the bits and add 1 memorize these: 0xFFFF.FFFF = -1...FE = -2...FD = -3...FC = -4...F0 = -16 and these while you're at it, memorize these too: 0xA = xD = x14 = x40= xB = xE = x1E = x50= xC = xF = x28 = x64=100 10

39 Binary Math (8 bit) unsigned signed hex number line V B CA 28 C 28 1C BD C C BD DD 154 C A BD C 66 V 42 signed unsigned

40 Unsigned/Signed Math (16 bit) UNSIGNED two small numbers 4,660=0x ,328=0x ,988=0x88AC two large numbers 35,243=0x89AB 52,719=0xCDEF 87,962=0x1579A two very large numbers 65,244=0xFEDC 52,719=0xCDEF 117,963=0x1CCCB SIGNED small +ve, small +ve big +ve, big +ve small -ve, small -ve big -ve, big -ve small +ve, small -ve 4,660=0x ,136=0x ,796=0x68AC 4,660=0x ,328=0x ,988=0x88AC -292=0xFEDC -12,817=0xCDEF -13,109=0x1CCCB -30,293=0x89ab -12,817=0xCDEF -43,110=0x1579A 4,660=0x ,817=0xCDEF -8,157=0xE023

41 Why do we use 2's complement? 1's complement just flip the bits -2 0xFD -1 0xFE 0 0 or 0xFF (either) 1 0x01. suppose we do a few math calculations xFD + 0x03 = 0x01 (+1 signed) but if we treat 0xFD as unsigned (253)... then 0xFD+0x03 = 0x02 (with carry) xFD + 0xFD = 0xFB (-4 signed) but if we treat 0xFD as unsigned (254) then 0xFD+0xFD = 0xFA (with carry) try these again in 2's complement, they work just fine we would need a different adder for signed & unsigned

42 Why do we use 2's complement? 2's complement flip the bits and add one -2 0xFE even number -1 0xFF odd number x01. suppose we do a few math calculations xFE + 0x03 = 0x01 but if we treat 0xFE as unsigned (254)... then 0xFE+0x03 = 0x01 (with carry) xFD + 0xFD = 0xFA but if we treat 0xFD as unsigned (253) then 0xFD+0xFD = 0xFA (with carry) we can use the same adder for signed & unsigned we just need different overflow conditions: C & V

ARM Assembly Programming

Introduction ARM Assembly Programming The ARM processor is very easy to program at the assembly level. (It is a RISC) We will learn ARM assembly programming at the user level and run it on a GBA emulator.