Instruções Assembly. César Yutaka Ofuchi (Adaptado do Prof. Hugo Vieira Neto) César Ofuchi

Transcrição

1 1 Instruções Assembly César Yutaka Ofuchi (Adaptado do Prof. Hugo Vieira Neto)

2 2 Instruções Novo Workspace IAR 1- Fazer download do novo workspace no site em laboratório2 2 Corrigir o caminho do arquivo de imagem em Examples- >options->linker->input 3 Rebuild All da pasta Examples

3 Instruções Novo Workspace IAR Fazer download do novo workspace na pasta laboratório 2 Modo simulação e modo placa base no mesmo projeto Escolha de pastas que serão ou não compiladas através do menu (botão direito na pasta) Options->Exclude from build Pasta excluída é marcada com um X Para trocar entre modo simulador e modo placa, clicar com o botão direito no projeto Examples ->Options- >Debugger->Setup->Driver Simulator para simulação JLINK/J-Trace para placa 3

4 4 Instruções Novo Workspace IAR - Pasta

5 5 Instruções Novo Workspace IAR - Pasta

6 Material de apoio: Referências Cortex-M3/M4F Instruction Set ARM and Thumb -2 Instruction Set (quick reference) Livro: The Definitive Guide to The ARM Cortex-M3 capítulo 4 6

7 Revisão Utiliza a versão de arquitetura ARMv7-M Conjunto de instruções Thumb2 Emprega instruções de 16 e 32 bits Arquitetura Load/Store Pipeline Instruções Condicionais ATPCS 7

8 8 Unified Assembler Language (UAL) Padroniza as pseudo-instruções a serem resolvidas pelo montador (assembler): POP, PUSH Relaxamento nas definições de Rd e Rn Rd : registro de destino Rn : registo de origem (parametro) Obrigatoriedade do sufixo S para alterar flags Especificadores de largura da instrução.w força instrução de 32 bits (Wide).N força instrução de 16 bits (Narrow)

9 9 Instruções de processamento de dados Exemplos: Aritmética: ADD ADC SUB SBS RSB RSC Lógica: AND ORR EOR BIC Comparação: CMP CMN TST TEQ Movimento de dados: MOV MVN Instruções somente trabalham com registradores e NÃO com a memória Sintaxe: <operação> {cond} {flags} Rd, Rn, Operando 2 <operação>: Mneumônico de 3 letras {cond} opcional: Código para instruções condicionais (EQ, CS, etc.) {flags} opcional: Habilita flags (S) Rd: Registrador de Destino Rn: Registrador de origem Operando 2: operando flexível

10 Instruções de Carga Carga de registrador MOV Rd, <Op2> Rd := <Op2> Carga de registrador negado MVN Rd, <Op2> Rd := /<Op2> Carga de MSB MOVT Rd, <Op2> Rd := /<Op2> <Op2> = registrador (deslocado) ou constant Números Negativos (Complemento de 2) 0x0001 (1 positivo) 0x (Inverte e soma 1) 0x1111 (1 negativo) 10

11 11 Instruções de Carga Move de um registrador especial para um registrador geral MRS Rd, <SReg> Rd<-SReg Move de um registrador geral para um registrador especial MSR <SReg>, Rm SReg<-Rm

12 12 Operando 2 -> Barrel Shifter Rd: Registrador de Destino Rn: Registrador de origem (operando 1) Ex: ADD R0, R1, R2 Rm Registrador de origem (barrel shifter->operando 2) Circuito Lógico Combinacional (delay muito pequeno) que pode deslocar os dados por um número de bits BCDA<- ABCD -> DABC

13 13 Deslocamento Lógico à Esq. (LSL) LSL{S} Rd, Rm, Rs LSL{S} Rd, Rm, #imm Efeito de LSLS Rm, #n é Rm x 2 n n >= 32: todos os bits são zerados n >= 33: todos os bits e o flag C são zerados Variante: LSLS (altera flag C) LSLS R1, R2, #3 ; Logical shift left by 3 bits with flag update

14 14 Deslocamento Lógico à Dir. (LSR) LSRS {Rd}, Rm, Rs LSRS {Rd}, Rm, #imm Efeito de LSRS Rm, #n é Rm / 2 n n >= 32: todos os bits são zerados n >= 33: todos os bits e o flag C são zerados Variante: LSRS (altera flag C) LSR R4, R5, #6 ; Logical shift right by 6 bits

15 15 Deslocamento Aritmético à Dir. (ASR) Variante: ASRS (altera flag C) ASRS{Rd}, Rm, Rs ASRS{Rd}, Rm, #imm ASR Efeito de ASRS Rm, #n é Rm / 2 n n >= 32: todos os bits e o flag C recebem cópia do bit 31 R7, R8, #9 ; Arithmetic Exemplo ASR por 4 (valor positivo) Exemplo ASR por 4 (valor negativo)

16 16 Rotação à Direita (ROR) Variantes: RORS (altera flag C) RORS {Rm}, Rm, Rs Apenas dois operandos Apenas registradores baixos (R0 a R7) n = 32: o valor não é alterado e flag C := Rm[31] n = 33: mesmo efeito que n = 1 ROR R4, R5, R6 ; Rotate right by the value in the bottom byte of R6

17 Rotação à Direita Extendida (RRX) Variantes: RRXS (altera flag C) RRXS Rd, Rm Inclui o flag C na rotação Rotação de um único bit à direita RRX R4, R5 ; Rotate right with extend. 17

18 18 ARM Barrel Shifter LSL: Logical Shift Left ASR: Arithmetic Right Shift Destination C 0 C Multiplicação por uma potência de 2 Destination Divisão por uma potência de 2 preservando o sinal LSR: Logical Shift Right ROR: Rotate Right 0 Destination C Destination C Divisão por uma potência de 2 RRX: Rotate Right Extended Rotação circular de n bits do LSB para o MSB Destination Rotação circular de 1 bit do flag C para o MSB C

19 19 Exemplos - Código MOV r0, r0, LSL #1 Multiplica R0 por 2. MOV r1, r1, LSR #2 Divide R1 por 4 (unsigned). MOV r2, r2, ASR #2 Divide R2 por 4 (signed). MOV r3, r3, ROR #16 Troca o MSB pelo LSB de R3.

20 20 Operando 2 Flexível <Op2> 0100 = Instrução ADD I =0 Operando 2 é registrador I= 1 Operando 2 é valor imediato 12 bits = 2^12 = bits = 2^8 = bits = 2^4 = 0-15 x x2 ROR

21 21 Exemplo 8 bits deslocados

22 22 Operando 2 Flexível <Op2> Deslocamentos permitidos: ASR #n 1 n 32 LSL #n 1 n 31 LSR #n 1 n 32 ROR #n 1 n 31 #Constantes permitidas: Valores de 8 bits deslocados Valores do tipo 0x00XY00XY (hex) Valores do tipo 0xXY00XY00 (hex) Valores do tipo 0xXYXYXYXY (hex)

23 23 Carga de Constantes de 32 bits Instruções MOV.W e MOVT simplificam a carga de constantes que não atendem aos padrões de 8 bits com deslocamento MOV Ri, #imm16 (MOV.W Ri, #imm16) carrega os 16 LSB de Ri, zerando os 16 MSB MOVT Ri, #imm16 carrega os 16 MSB de Ri imm16: Is a 16-bit immediate constant MOV = MOV.W

24 24 Instruções Lógicas e Aritméticas

25 Instruções Lógicas e Aritméticas 25 25

26 26 Instruções Lógicas e Aritméticas Formato Três operandos explícitos (Rd, Rn, <Op2>) ADD R0, R1, R2 R0 := R1 + R2 Dois operandos explícitos e um implícito (Rd, <Op2>) ADDS R0, R1 (flags) R0 := R0 + R1 válido apenas para algumas instruções (UAL). Dois operandos (Rn, <Op2>) CMP R7, R8

27 27 Adição e Subtração ADD{S}, ADC{S} Rd, Rn, <Op2> ADD R0, R1, R2 R0 := R1 + R2 (adição) ADDC R0, R1, R2 R0 := R1 + R2 + C SUB{S}, SBC{S} Rd, Rn, <Op2> SUB R0, R1, R2 SBC R0, R1, R2 R0 := R1 - R2 R0 := R1 - R2 - C (subtração) RSB{S} Rd, Rn, <Op2> RSB R0, R1, R2 R0 := R2 - R1 EXEMPLOS COM OPERANDO 2: ADD r4, r4, r4, LSL #4 Multiplica R4 por 17. (N = N + N * 16) (subtração reversa) RSB r5, r5, r5, LSL #5 Multiplica R5 por 31. (N = N * 32 - N)

28 28 Operações Lógicas AND{S} Rd, Rn, <Op2> Operação AND ORR{S} Rd, Rn, <Op2> Operação OR EOR{S} Rd, Rn, <Op2> Operação EXCLUSIVE OR ORN{S} Rd, Rn, <Op2> Operação OR NOT BIC{S} Rd, Rn, <Op2> Operação AND NOT (bit clear)

29 Comparação / Teste Lógico <operação> {cond} Rn, Operando 2 atualiza flags!! CMP Rn, <Op2> afeta flags com Rn - Op2 (comparação) CMN Rn, <Op2> afeta flags com Rn + Op2 (comparação negativa) TST Rn, <Op2> afeta flags com Rn AND Op2 (testa bits AND bit-a-bit) TEQ Rn, <Op2> afeta flags com Rn EOR Op2 (testa equivalência) EOR = Ou Exclusivo Rn: Op2: Res: ZERO quer dizer igual 29

30 Exercício 1 Qual a maneira mais eficiente (menos instruções e menos tempo de execução) para fazer as seguintes cargas de constantes? a) R0 := 0 b) R1 := 200 c) R2 := 0x1234 d) R3 := 0xFFFFFF00 e) R4 := 0xABCDEF00 30

31 Exercício 2 Programa em Assembly: Atividades: INICIO: MOV R1, #3 MOV R2, #5 MOVS R3, #-6 ADD R0, R2, R3 ADDS R0, R2, R3 ADDS R0, #9 CMP R0, #8 SUBS R0, #10 SUBS R0, #256 SUBS R0, #3000 a) Corrigir e explicar erros de montagem do programa b) Interpretar valores c) Interpretar flags 31

32 MUL Rd, Rn, Rm Rd := Rn x Rm Multiplicação (32 bits) Formato preferido: MUL Rd, Rn Apenas registradores baixos (R0 R7) MULS Rd, Rn, Rm (Rd==Rm) Rd := Rn x Rd Afeta flags N e Z, mas neste caso Rm deve ser o mesmo registrador que Rd Ex: (MULS R0,R2,R0) 32-bits x 32-bits -> 32-bits em 1 ciclo de clock 32

33 33 Multiplicação Acumulada (MLA) MLA Rd, Rn, Rm, Ra Rd := Ra + Rn x Rm MLS Rd, Rn, Rm, Ra Rd := Ra - Rn x Rm 32-bits x 32-bits -> 32-bits em 2 ciclos de clock

34 34 Multiplicação Longa (64 bits) Multiplicação longa não sinalizada (Unsigned): UMULL RdLo, RdHi, Rn, Rm RdHi:RdLo := Rn x Rm Multiplicação acumulada longa não sinalizada: UMLAL RdLo, RdHi, Rn, Rm RdHi:RdLo := RdHi:RdLo + Rn x Rm 32-bits x 32-bits -> 64-bits em 3 a 5 ciclos de clock

35 35 Multiplicação Longa (64 bits) Multiplicação longa sinalizada (Signed): SMULL RdLo, RdHi, Rn, Rm RdHi:RdLo := Rn x Rm Multiplicação acumulada longa sinalizada: SMLAL RdLo, RdHi, Rn, Rm RdHi:RdLo := RdHi:RdLo + Rn x Rm 32-bits x 32-bits -> 64-bits em 3 a 5 ciclos de clock

36 Divisão Divisão não sinalizada (Unsigned): UDIV Rd, Rn, Rm Rd := Rn / Rm Divisão sinalizada (Signed): SDIV Rd, Rn, Rm Rd := Rn / Rm 32-bits / 32-bits -> 32-bits em 2-12 ciclos de clock Pode gerar exceção na divisão por zero (configurável) 36

37 37 Exercício 3 Multiplicar o valor inteiro (32-bits) que está em R3 pela constante 9: (R3=2) a) Usando instrução de multiplicação b) Sem usar instrução de multiplicação (sugestão: adição/subtração/deslocamento) c) Idem, mas agora multiplicando o valor que está em R3 pela constante 15. a) Explicar o resultado dos comandos anteriores

38 38 Operações em Bits

39 Operações em Bits Bit-field Clear: Zera #w bits a partir de #lsb em Rd BFC{cond} Rd, #lsb, #width Exemplo BFC R4, #8, #12 ;zera bit 8 ao bit 19 (12 bits) Bit-field Insert: Copia #w bits de Rn:0 para Rd:#lsb BFI{cond} Rd, Rn, #lsb, #width Exemplo BFI R9, R2, #8, #12 ;troca bit 8 ao bit 19 (12 bits) de R9 ;pelos bits 0-11 de R2 39

40 Operações em Bits Signed Bit-field Extract: Copia #w bits a partir de #lsb para o bit 0 de Rd e estende sinal. SBFX Rd, Rn, #lsb, #w Exemplo: SBFX R0, R1, #20, #4 ;Extrai bit 20 a bit 24 (4 bits) de R1, estende ;sinal para 32 bits e escreve em R0 Unsigned Bit-field Extract: Copia #w bits a partir de #lsb para o bit 0 de Rd e estende com zeros UBFX Rd, Rn, #lsb, #w Exemplo: UBFX R8, R11, #9, #10 ; Extrai bit 9 a bit 18 (10 bit) de R11, estende ;0 para 32 bits e escreve em R0 40

41 Programa em Assembly: Exercício 4 INICIO: MVN R0, #0 MOV R1, #0xCCDD MOVT R1, #0xAABB BFC R0, #4, #8 BFI R0, R1, #8, #12 SBFX R0, R1, #4, #8 UBFX R0, R1, #4, #8 Atividades: a) Interpretar resultados das instruções BFC e BFI b) Interpretar os resultados das instruções SBFX e UBFX 41

42 42 Operações de Extensão

43 43 Operações de Extensão SXT e UXT Signed Extend Byte to Word: SXTB Rd, Rm // Rd := sign extend Rm[7:0] Unsigned Extend Byte to Word : UXTB Rd, Rm// Rd := zero extend Rm[7:0] Signed Extend Halfword to Word: SXTH Rd, Rm // Rd := sign extend Rm[15:0] Unsigned Extend Halfword to Word: UXTH Rd, Rm // Rd := zero extend Rm[15:0] Apenas registradores baixos (R0 a R7)

44 44 Operações de Reversão

45 45 Operações de Reversão Reversão dos bits de uma word: RBIT Rd, Rm Reversão dos bytes de uma word: REV Rd, Rm Reversão dos bytes de ambas as halfwords de uma word: REV16 Rd, Rm Reversão dos bytes da halfword menos significativa de uma word, com extensão de sinal: REVSH Rd, Rm

46 46 Instruções de Salto

47 47 Instruções de Salto Salto incondicional B{cond} label Salto condicional (única instrução condicional que não precisa estar em bloco IT): B{cond} label Ex: BEQ Chamada de subrotina (armazena endereço de retorno em LR): BL label Ex: (end) BL rotinax rotinax (LR=end) Retorno de chamada de subrotina (PC := LR): BX{Rm} Ex: BX LR ou PC=LR

48 48 Limites de Abrangência

49 49 Instruções de Comparação e Salto Testa Rn e salta se for diferente de zero: CBNZ Rn, label Compare and branch if not zero Testa Rn e salta se for igual a zero: CBZ Rn, label Compare and branch if zero Restrições: Apenas registradores baixos (R0 a R7) Apenas saltos para frente de até 130 bytes Não pode ser usado em bloco IT Não afeta flags

50 50 Acesso à Memória Load/Store <operação>{cond}{tam} Rd, <endereço> LDR Rd:=valor no endereço ex: LDR R0, [R1] R0=<R1> STR valor no <endereço> = Rd ex: STR R0, [R1] <R1>=R0 {tam} B: byte SB: signed byte H: halfword, SH signed halfword

51 51 Instruções de Acesso à Memória Load

52 52 Instruções de Acesso à Memória Store

53 53 Instruções LDR (Load) Leitura de word apontada por registrador: LDR Rd, [Rn, {#off}] Leitura de halfword apontada por registrador: LDRH Rd, [Rn, {#off}] Leitura de byte apontado por registrador: LDRB Rd, [Rn, {#off}] Restrições: Somente registradores baixos (R0 a R7) e SP #off: (SP), (R0 a R7), (LDRH) (LDRB); somente valores positivos #off deve ser *4 para LDR e *2 para LDRH

54 54 Instruções LDR (Load) Indexação por registrador: LDR Rd, [Rn, ±Rm {, <opsh>}] LDRH Rd, [Rn, ±Rm {, <opsh>}] LDRB Rd, [Rn, ±Rm {, <opsh>}] <opsh> = deslocamento opcional Exemplo: LDR R0, [R1, R2, LSL #2] //end = R1 + R2<<2

55 55 Pré e Pós-indexação Acesso pré-indexado: Primeiro atualiza endereço, depois acessa memória Usar! para atualizar o ponteiro LDR Rd, [Rn {, #off}] {!} LDR Rd, [Rn, ±Rm {, <opsh>}]{!} Exemplos: LDR R0, [R1, #4] LDR R0, [R1, R2]!

56 56 Pré e Pós-indexação Acesso pós indexado: Primeiro acessa memória, depois atualiza endereço Sempre atualiza o ponteiro LDR Rd, [Rn] {, #off} LDR Rd, [Rn], ±Rm {, <opsh>} Exemplos: LDR R0, [R1], #4 LDR R0, [R1], R2

57 57 Carga com Extensão de Sinal Leitura de halfword com extensão de sinal: LDRSH Rd, [Rn, #off] LDRSH Rd, [Rn, ±Rm {, <opsh>}] Leitura de byte com extensão de sinal: LDRSB Rd, [Rn, #off] LDRSB Rd, [Rn, ±Rm {, <opsh>}]

58 58 Acessos Alinhados Um acesso à memória é alinhado se: Para Word: endereço múltiplo de 4 Para Halfword: endereço múltiplo de 2 Para Byte: endereço múltiplo de 1 No Cortex-M3 os acessos podem ser desalinhados

59 59 Acessos Múltiplos à Memória Leitura de múltiplos registradores da memória: LDMIA Rn{!}, <reglist> LDMDB Rn{!}, <reglist> Escrita de múltiplos registradores na memória: STMIA Rn{!}, <reglist> STMDB Rn{!}, <reglist> Exemplos: LDM R0, {R0, R1, R2} STM R0!, {R2-R4}

60 60 Acesso Multiplo à Memória LDM/STM Operação: LDM / STM (Load Multiple, Store Mulltiple) <modo endereçamento> USUAL STACK IA: Increment After FA:Full Ascending IB: Increment Before EA:Empty Ascending DA: Increment After FD: Full Descending DB: Decrement Before ED: Empty Descending Rn: registrador base contendo o endereço inicial Lista de registradores {R3, R5}: separado por virgula endereça cada elemento R3, R5 {R3 R5} : separado por traço (-) endereça o conjunto R3, R4, R5 operação<modo end.>{cond} Rn{!}, <lists de reg.>

61 61 Acesso Multiplo à Memória LDM/STM operação<modo end.>{cond} Rn{!}, <lists de reg.> Exemplo1: load múltiple, Increment After Tem o mesmo efeito que 4 instruções LDR

62 62 Acesso Multiplo à Memória LDM/STM operação<modo end.>{cond} Rn{!}, <lists de reg.> Exemplo2: load múltiple, Increment After Carrega o conteúdo endereçado por r9 em r0, r1, r2,r3 e r12 Incrementa r9 em cada carregamento Se quiser atualizar o valor de r9 usar o!

63 63 Acesso Multiplo à Memória LDM/STM <modo endereçamento> USUAL STACK IA: Increment After FA: Full Ascending IB: Increment Before EA: Empty Ascending DA: Increment After FD: Full Descending DB: Decrement Before ED: Empty Descending

64 64 Tipos de Pilha Normalmente Rn = SP (R13) Usar! para atualizar o ponteiro Full Descending Stack STMFD = STMDB (decrement before) LDMFD = LDMIA (increment after) Empty Ascending Stack STMEA = STMIA (increment after) LDMEA = LDMDB (decrement before)

65 Tipos de Pilha STMDB SP!, {R0,R1,R3-R5} STMIA SP!, {R0,R1,R3-R5} STMFD SP!, {R0,R1,R3-R5} STMEA SP!, {R0,R1,R3-R5} 0x418 SP r5 r4 r3 r1 Old SP r5 Old SP r0 0x400 r4 r3 r1 SP r0 0x3e8 DB : Decrement Before IA : Increment After FD : Full Descending EA : Empty Ascending 65

66 66 PUSH e POP Implementam uma estrutura de pilha do tipo Full Descending Stack PUSH {R0,R1,R3-R5} STMFD SP!, {R0,R1,R3-R5} POP {R0,R1,R3-R5} LDMFD SP!, {R0,R1,R3-R5} Lista de registradores pode incluir LR (R14) e PC (R15)

67 67 Mapa de Memória RAM STACK HEAP DATA (.data) (.bss)

68 Exercício 5 Programa em Assembly: Atividades: INICIO: MOV R0, #0x3344 MOVT R0, #0x1122 MOV R1, #0xCCDD MOVT R1, #0xAABB STMIA SP!, {R0, R1} LDMDB SP!, {R0, R1} PUSH {R0, R1} POP {R0, R1} a) Observar os efeitos das instruções no registrador SP e na memória (pilha) b) Remover o! das instruções STM e LDM e observar o efeito no registrador SP c) Trocar os sufixos IA e DB das instruções STM e LDM e observar o efeito na memória (pilha) 68

69 Bloco If-Then (IT) IT <X><Y><Z><COND> Execução Condicional <X,Y e Z> são até 3 opcionais (T) them ou (E) else <COND> condições como NE, EQ, etc que são flags do APSR Até 3 instruções condicionais then (T) ou else (E) podem ser adicionadas Instrução minima (IT) com apenas uma condicional No máximo 4 instruções consecutivas em condicionais Qualquer código de condição ARM pode ser utilizado (ver tabela a seguir) 69

70 Códigos de Condição ARM APSR N Z C V Negative Zero Carry Overflow Mn Descrição Flags Mn Descrição Flags EQ equal Z NE not equal Z CS HS carry set higher or same C CC LO carry clear lower C MI minus/negative N PL plus/positive N VS overflow V VC no overflow V HI higher ZC LS lower or same Z + C GE greater or equal NV + N V LT less than N V + NV GT greater than N ZV + N Z V LE less or equal Z + N V + N V 70

71 71 Exemplo CMP <Rn>, Op2 Descrição: Faz Rn-Op2 CMP R0, #10 ;compara R0 com 10 ITE LO ;Bloco IT (R0<10)? ADDLO R0, #1 ; then R0=R0+1 (se for menor) C=0 MOVHS R0,#0 ; else R0=0 (senão) C=1

72 72 Blocos IT (If-Then) A instrução de salto condicional B{cond} label é a única que não precisa estar em bloco IT As seguintes instruções não podem estar em bloco IT: Bloco IT: IT Branches: CBZ, CBNZ Processor State Change: CPSIE, CPSID Uma instrução que altera o PC, só pode estar em bloco IT se for a última instrução do bloco

73 73 IT-Barrel Shifter - Exercício 6 (entregar) Gerar um código em assembly que utilize o bloco IT e teste as quatro flags (N,Z,C,V) Pelo menos um dos testes deve ter GT/LE Testar o uso da flag S nas instruções dentro do bloco IT Usar instruções de comparação Usar Barrel Shifter Comparar o tempo computacional desse código com o equivalente em C (disassembly) Mandar para o ofuchi@utfpr.edu.br para a próxima aula Colocar no assunto NOME_TURMA