EDA365电子论坛网

标题: ARM体系结构与编程学习（12） [打印本页]
作者: piday123    时间: 2021-2-5 10:06
标题: ARM体系结构与编程学习（12）

, u* a3 a8 k+ p+ I9.4 SWI异常中断处理程序
1 _7 M8 f- g; P- E: s* j" N# {% g( u
在实时操作系统中，通常使用SWI异常中断为用户程序提供系统功能调用。. d5 `0 n' s& n. @6 r  U
* o9 f1 j! J* Z7 b- l
通常SWI异常中断处理程序分为两级：  u' Z: @0 M+ I  y$ ?: A( X

7 {3 r$ J+ G. C7 x1 ?5 ?第1级SWI异常中断处理程序为汇编程序，用于确定SWI指令中的24位的立即数；  e! u/ r* {/ E7 i' S/ @8 Q/ c% R

: m, a* g5 d7 ~7 P第2级SWI异常中断处理程序具体实现SWI各个功能，可以是汇编，也可以是C程序。
: p' t, ~! S6 f% W* Z. g
: x" D/ |5 J5 j8 T2 |
8 D( q& q, Z" a4 |5 e3 L7 u( I4 E8 y4 J5 {$ n& a
第1级SWI异常中断处理程序' g% A! u1 D0 l1 Q) `
; l1 c! f+ O* a  ^- k
        AREA  LevelOneSWI  ,CODE ,READONLY6 |. k# ~4 H- |0 n& i1 M

" C* d8 J2 O( o/ A% f* i" g. e        EXPORT  SWI_Handler
+ y5 X! S, q1 ?% {: T
/ z. Y% d* H2 W/ JSWI_Handler+ F1 M+ L: _( q% \- |/ |! x8 e) d

1 {  `' j) S8 I9 z& x* Q8 E1 v. Y. w$ ];保存用到的寄存器
/ J3 n" [# N8 L
& P. X" J/ M* B8 U" z, p: L2 a        STMFD  SP!,{R0-R12，LR}; O3 m) M5 E& A. K3 Z* m
: d2 D! e3 u1 U8 i' |; C
;计算SWI指令的地址，并把它读取到寄存器R0中
9 m1 ~) J1 J2 \$ S2 e9 y5 z' \% f3 N* U" `( u" s0 j3 r3 b* m
        LDR  R0，{LR,#-4}; H  U9 ]4 i9 v: C  E

/ u' w" x* w3 \5 M7 ~+ j, w;将SWI指令中的24位立即数存放到R0寄存器中8 }2 s0 k! \* g
: K6 L' a. }3 x8 ?
       BIC   R0，R0，#0XFF000000
6 ^1 H5 M3 ^% S4 N
* }$ r' O+ m! |7 Q8 ~% ?;使用R0寄存器中的值，调用相应的SWI异常中断的第2级处理程序
8 L8 e0 H  c- [" o: K; B& ?
+ a$ {# U  z4 t8 y) h  S;+ x" H: l0 i0 t; W$ K6 \. z

; h- J) K, h: Z7 F  \, u: p% y4 ?;恢复使用到的寄存器，并返回
( H7 k& Q0 g/ }! t0 V5 w. \' \& ~1 Z4 D) @
        LDMFD  SP!,{R0-R12，LR}  [: U) B& _. s3 b2 U0 n, p5 {
* T/ Z$ S, T8 P! K! x
        END6 H, Y) `& Z' c( }' L" F6 z  j
# N/ Z4 O) Y2 s8 e0 n
' D' y) J+ Y/ T

4 f6 M5 a0 u( x+ a' T# t* l( i第2级SWI异常中断处理程序（使用汇编）& m6 O5 s9 ~2 a* W  s) o# F

& I- b3 a$ w  q  C! v! N   ;判断R0寄存器中的立即数是否超过允许的最大值
8 q/ ]* G# b# B$ T: A8 o: F; l  w* r, }  Q- P6 p
        CMP  R0，#MAXSWI
/ r9 ^' L" a! c% x  b  J  R6 S; q3 C5 J( e  z+ C7 o8 {* A
        LDRLS  PC, [PC,R0，LSL #2]+ \& a- ^) H2 q

: Y$ w0 o& k4 c( G        B  SWIOutOfRange! V" x9 `1 g$ E" v9 u( N
- @" `" J6 W. V. ]4 ^- }* M
SWIJumpTable# {7 P/ c0 l' F7 y1 K! o0 C. b
- Q, [- M+ v2 v8 ]* o
        DCD  SWInum00 ^  e4 s$ r" v4 \' P- K# T+ h$ D
8 |' ?# j% s) o: A3 L9 E6 M  k
        DCD  SWInum1
2 c. f* N$ ?: D) ?7 B0 \
# c9 J: f- R8 l" S: C, R9 j    ;其他的DCD% w( q& ?! @  k# X+ E

* r5 Z% |( \, Q$ ?3 \* }& w    ;
- z7 o6 ?8 f+ C. ]0 `
/ ?  C& {- k5 q' B( p    ;立即数为0对应的SWI中断处理程序, i; ~2 I" L' |# P" \" M3 {

% S, [: s$ ?' E8 YSWInum0
" P# m/ k% w, i& E: N' x% L( Z! x0 `( s5 O: j' |+ A
        B  EndofSWI
% P+ A( _- L7 I1 W' [
* n8 M* q1 m' Q; [9 W' m;1 H) [- K' k, A( y+ q1 [1 G

* Z# j: n) V) x# O;其他的SWI中断处理程序
0 F5 m  P* j* a* Y2 x& R; p6 R! ?) ~
4 V5 @& q% v2 O( D;# N" {( Z" S& a) ?9 b$ u  |
! h: ]6 J3 v: [% Q& O! s
;结束SWI中断处理程序
, |2 Q0 n$ _0 O- d& @3 ]% K4 L6 }9 [# g% `3 k
        EndofSWI
, x4 }7 u5 ]0 Y" ]5 A- \8 s' t0 G( h* H- @8 E
% N# p+ ]% T& B/ Q  u0 E7 b

/ j" W2 W  U* T) G2 S+ k将第1级和第2级程序组成完整的SWI中断处理程序5 {" _' B# Y" [2 B6 S9 T! P3 n

" Y3 c2 O: ]) r        AREA  LevelOneSWI  ,CODE ,READONLY
9 j6 U" k% u# b
. W  c, P/ Q+ b7 H) U6 [# j        EXPORT  SWI_Handler0 Z5 n& A& K. s: c6 `2 u( h& e# V

3 F1 j! a! G9 E8 CSWI_Handler( K- p- c, f' P4 m9 L
7 ?+ {! B6 t9 d  |# p/ t' S% |# G! P
;保存用到的寄存器* d! ]9 @  M* I( z( I/ D

* W! T$ h8 O. P) m. g" c        STMFD  SP!,{R0-R12，LR}
" g% q) Z4 O, x. k. N
5 Q$ ^3 B- m; A9 {) K4 R1 F" i/ V  { ;计算SWI指令的地址，并把它读取到寄存器R0中# i- Y+ g* J0 p% u

+ D6 a+ D) _6 |3 G3 F- K- B$ R        LDR  R0，{LR,#-4}* W+ h5 K9 `' v/ r  Y
  m+ \7 r$ }/ v, f$ y0 ~. g
;将SWI指令中的24位立即数存放到R0寄存器中
& I: V- Y4 T5 V* d
) ~' G8 r: @! Y: V       BIC   R0，R0，#0XFF000000
1 X/ K, H8 w7 ~) M$ \4 E: h0 r
3 X9 O" p9 T. O) c  _$ }  O0 h$ ~;使用R0寄存器中的值，调用相应的SWI异常中断的第2级处理程序& E- V& i8 `6 ^% v. b+ m
% P: _. u  B2 r& q6 t8 ]$ g
;+ A0 Y3 H+ l: L$ P

, |: c+ [% e3 l8 c   ;判断R0寄存器中的立即数是否超过允许的最大值7 J5 }1 Q" J4 z8 Q1 j
7 C% j, {% o, N' Z6 s
        CMP  R0，#MAXSWI* ^6 w+ v  s3 k( z# _
3 ^4 b3 F! Z+ W7 b
        LDRLS  PC, [PC,R0，LSL #2]
) w! P! P* S% y0 [4 b: a, p: f* U3 Y7 K. M# y* X8 H
        B  SWIOutOfRange
0 {) {" b7 R/ E0 T" t6 W
3 d$ x- I9 t; g. `1 g: S' ~SWIJumpTable
* |9 O  H& `' \2 Q1 n) q+ G& w$ w7 C6 H& \3 n3 ^. {
        DCD  SWInum0
# e! h; D/ O1 @! l6 j. T7 D; v+ K" w
        DCD  SWInum1* U) m* v. ~2 E; L, k- R0 b8 G

2 ^7 [% h7 C1 I7 l, F& P* j( d0 d    ;其他的DCD! k/ D1 W$ R2 z8 r8 z

" }/ c9 ~5 G. O$ H/ X0 k    ;
7 H- w# Z7 K$ K' x
* E# @& r( m. Z9 ^. Q& y% C* M/ U# c    ;立即数为0对应的SWI中断处理程序
3 W$ E5 I2 p; Z! n/ J, U, S4 I2 B
$ X' k' ?1 n$ V  X1 _# R' ^SWInum0
, U- r: {( l' A- a( P9 H2 O0 B" o$ V! w
        B  EndofSWI
. p# M$ f" O! [$ Q; c( R8 i' ]
+ ~( G& P( U  ?; Q9 D6 p+ X, mSWInum1! y  }2 @' o  _+ B$ x/ d" y
# k+ W* s( D4 m1 z7 t
        B  EndofSWI
" o' h; h7 ?- L! G2 L/ v5 Y
: r! k  t0 ?/ R: ?;% n; f+ M( j) E/ k7 Z+ T

* s* v# {( l4 i+ N$ {# u" j;其他的SWI中断处理程序
5 k) B8 I( ~0 s& u3 a$ t* l" D0 [
& }1 m& a; O2 v! H8 P6 ~& ^( M8 o;
/ C; F6 _9 }( h
& q# ~3 \$ k+ N( p;结束SWI中断处理程序
& a4 {: X+ G- o, W0 }/ a0 L) R6 w. u2 v4 u
        EndofSWI, V0 E* H/ Z5 q& z6 k# N/ r5 z8 u

- L' h) B4 i* s! h;恢复使用到的寄存器，并返回
4 ?2 d" n7 \/ a: L% y
$ o2 d4 a+ n) b; j7 M        LDMFD  SP!,{R0-R12，LR}! W9 V: _: P! r
1 j" Z# j, h3 J0 H
        END$ @, O% B% h/ X5 r5 ~+ e4 L5 N

' @9 @* M& J3 l) a6 Z6 w$ e9 m
' Y3 j3 p+ P% Y* M, e  E% \; g5 l
第2级SWI异常中断处理程序（C程序）' m, ?6 M1 q1 s' X6 a" z
1 U1 ?7 s; k$ J" V
void  C_SWI_Handler (unsigned number )
9 U( Z0 O- W- {7 _  c9 L" q+ O: X
9 j1 M2 {: T* R{( e% l  t* K; O
      switch  (number)
/ \# M6 B' ^% L7 p2 R
7 e5 z4 U* ^% i      {
# _' c9 d  b% s7 l7 L2 T         case 0:4 C! X& Z+ z" d# ~* C8 W! b
* F  W+ a9 m, C  Y+ V
       //SWI为0时执行的代码
2 x, h6 g& H$ D+ R. l) ~5 U# L4 Q5 `2 S# v$ g, H
        break;
7 t( |9 r: B4 M6 u, L7 ^
! p# L! q/ o' i) o$ F         case 1：5 d0 `, U4 [+ ~6 Z4 Y

# Z( Y- Z) K; |* b1 u( [  y       //SWI为1时执行的代码# S3 ^/ b6 y0 V- \+ {
- h/ Q7 }/ i- X) i
        break;0 c3 r, P/ W# `# c% z$ Z. b

6 O8 G; S, a+ y- Y9 Q        //其他SWI号执行代码1 ~5 \8 o8 e  Z! Q* M& v$ ]

1 j6 [3 B4 D3 O) _2 d 0 C' K5 D- L8 G2 |
1 m( R- W0 G! w7 _
       default：. ^( t, K6 n+ n( u
' D, H. _: f: j6 g% H
        }
: N  V: t: D$ e6 z) }8 p
& K; M5 o* t& r1 d/ s}
6 I0 [: v; A6 i3 k( Z3 k- A2 y. ]# v9 F- p

0 v, y* q1 ]; [
+ D; d) w( J3 g& [. [3 K5 v4 c一个完整的中断处理程序为C程序的SWI异常中断处理程序
* x, F4 Q8 h) J6 h- {, U4 S3 U+ q, ]4 G8 n! o5 i2 z% k
        AREA  LevelOneSWI  ,CODE ,READONLY
6 o1 G6 @1 a) ?5 I# _7 e4 A- ]2 T/ L5 g$ X
        EXPORT  SWI_Handler
' C) K5 k/ ~- v. R* [/ Q, s4 P  |+ u* d; }: w' y( d, p
        IMPORT  C_SWI_Handler
- h' X8 ~$ ^. c, l7 [. q8 B7 @5 J8 U* M* X( a) ?3 a: c% H) g
SWI_Handler
9 P- g; l# h5 s, _- B4 U$ A: i* V- ^5 Z
;保存用到的寄存器
& A2 e5 L# |; p( ~% M! ~" v1 C
- `9 @, H/ E0 l6 p# Z* R        STMFD  SP!,{R0-R12，LR}
/ D  c( j) K$ G) S. |8 D* J* c1 ~* y& I
;计算SWI指令的地址，并把它读取到寄存器R0中7 s6 @2 Y* k5 y0 {) A/ D* h+ P

2 _5 L% \6 \, X+ _: Z! G7 e" v        LDR  R0，{LR,#-4}5 Y& Z1 J1 I" D! Q& k
* \+ o1 k+ x4 ~3 y3 I7 u& u5 I; Y
;将SWI指令中的24位立即数存放到R0寄存器中* w& D/ s7 S: e8 u3 ]

+ u6 F$ v( t" D- r, M6 h9 X# T       BIC   R0，R0，#0XFF000000
4 w- B. [. E) Z
4 Z7 R8 U5 A! b;使用R0寄存器中的值，调用相应的SWI异常中断的第2级处理程序- f) g- s2 {; P# a  a

8 R# l9 s; a8 I: J" a4 `;
4 _0 u3 I" X! l& _7 m  }; j* d% A1 v4 T
       BL  C_SWI_Handler0 M: S) k" t& j2 N" t' X0 K

$ X, {- H$ q/ ^1 }4 t' b( L; ^;恢复使用到的寄存器，并返回/ ^/ E3 c- l  x9 o, i( @, l0 a
' S5 G. `( S' v
        LDMFD  SP!,{R0-R12，LR}
2 H3 K; x3 D) V4 h; m/ X: n: f, C+ _3 W3 k$ @# ]2 I5 D( o. S
        END
4 F& ^( r6 @. J( h; B4 |0 A
! l' ~) L: L& W/ R 2 E$ O2 M: U# {2 p% e
6 J, V7 T* F1 j4 t
9.4.2 SWI异常中断调用
  p: f. ^* P' }$ {( C6 R2 q7 ]! O7 `+ R0 q% h- ]
1、在特权模式下调用SWI
" @% N6 H* ~7 G6 G" J5 {/ f2 E  _: W. X9 x0 T
;保存用到的寄存器，保存R14_svc4 O. L# n! W% {% E0 h
- g! d% p$ r" c5 a8 k6 J
        STMFD  SP!,{R0-R3,R12,LR}
- V2 B) w6 v; N* L. A% Z7 T( ?7 z+ P, ~
;保存SPSR_svc6 E6 R. `. {% i$ O/ ~% D9 K& @

# K. H  ^$ o  T7 i, F0 v+ A        MOV R1 , SP; n9 A/ C. ~, k* m* y) J4 ~2 \  d) I

7 b' ?! c" G' I+ V4 N' A        MRS  R0,SPSR$ ?* W  \# j. v

% U5 T0 c* z6 v( x- V# H5 k        STMFD SP!,{R0}
/ F+ H# N2 ]$ ^1 f0 g5 }
# {% l" m  N, {3 [, \        
  h* r1 [4 y( q1 @8 G& H
* d. z: U2 y9 R2 A# P;读取SWI指令
. g) j- n) Y4 x+ [
: P0 h' v4 p* x        LDR R0,{LR,#-4}1 e) [2 @  E( W! O

( X2 k" o# L+ {  a ;计算其中24位的立即数，并把其放入R0
6 k5 T% n8 Z$ z0 e( i/ }; |$ L( K* k/ ~4 g5 o4 G
       BIC  R0,R0,0XFF000000
0 ?% W0 k: V+ y% V7 p" d( v  |
5 U$ _* F: o8 \4 N5 C' K;调用C_SWI_Handler! B  N6 R$ f/ h% F

2 i( y; e3 R3 k! e& @7 W       BL C_SWI_Handler
( y. e% q: I. K3 d" C7 b6 z9 t& h8 M* F3 R" y" N
;恢复SPSR_svc
+ O. k# I" O) c- Z2 k( H6 F* T3 K3 m$ Y. ]! Y' S
       LDMFD SP!,{R0}% {7 q1 z; k: [! x3 _
+ x! Z  E; J0 S0 \
       MSR   SPSR_svc, R0
, h: e1 @: `1 m1 i6 O& z  F& B5 _6 Z4 a" y
;恢复其他寄存器，包括寄存器LR_svc2 B- x9 N5 a2 V$ A2 M1 B$ [
  C3 r. G2 I+ l4 f. S8 \# k
       LDMFD  SP!,{R0-R3，R12,PC}^% F3 K! H/ m9 s& }7 X: n! R
- v, `8 ~9 W0 [* ?5 v; f" L6 Q

/ l- b/ Z; `6 ?( }: l! h- e/ \: r
: p% _  e: W& |' F% [! r. ^# X2从应用程序中调用SWI
9 Y/ d7 Y+ }8 h1 V/ o
5 v5 r* i" q9 b/ p5 ^( v分两种情况：1是使用汇编指令调用；2是使用C程序调用
+ I9 O  j* I+ N3 }
6 i! j& V) T' a汇编调用：7 N' X1 ?# g! _; l; O

- ]0 s! ~" I" `' ^! u  m+ b          MOV R0,#100   ;将参数放到寄存器中* W. Q2 d  N# s

( g4 R& o& r) R7 s$ d! g9 \          SWI  0X0         ;调用的SWI功能号
6 W& Q; c. f) U) G6 O( O$ `; a3 q  ]  d, p6 g
C程序调用：( N* L, U0 c2 E& c/ ~: Z" O+ J

! V" [/ n1 q9 C; B% I7 ?% O8 Q//头文件swi.h
1 W/ e! C- e  v& j% y0 I: P. K1 S/ F! ]5 \- Z2 j  G
__swi(0) int multiply_two(int, int);# b% Z' v5 f* S: Q
__swi(1) int add_two(int, int);  a( ]5 `" P/ B% [$ @, _3 p  i
__swi(2) int add_multiply_two(int, int, int, int);
0 x4 [7 s* l) [+ L) d8 x  T5 D0 z1 A
struct four_results  T$ y6 C! Z+ J. m( {
{
2 M6 N( ?& r/ O. R    int a;7 O0 C! t4 V" d5 V
    int b;
# y; C5 ?9 m0 C0 q' g# `8 D  {    int c;! s8 f6 M( B) W1 @! d2 N
    int d;$ @: N2 [& `# K- V
};
0 U0 N; Y$ F" y" \6 l# W: |
3 D' |8 b5 G& e" g% L2 b__swi(3) __value_in_regs struct four_results  p2 W& W- \; j$ y; `2 Y
    many_operations(int, int, int, int);9 O; B. t+ z1 d- L3 q+ O9 p3 T
4 K3 d2 t9 d- k7 o! Y9 W
. ]8 p5 O# @6 _2 F9 J3 E; q

$ d; p3 w6 D: l//主函数" M, Z# B8 M: V2 ~/ @+ A5 K, g
6 Q; W# p2 b2 l% Y
#include <stdio.h>
+ c- p* I  i; h0 ~- @#include "swi.h"
' `, n) l# W- |: ~/ V6 s2 |, i) w, z7 A, {
unsigned *swi_vec = (unsigned *)0x08;
; u" _8 D( _/ Sextern void SWI_Handler(void);% L; b# h( n7 x  |! a
, `/ u1 {7 P# C  F! Z& s

! m! A# [7 `  n2 q9 {: i
# n8 ^! k( @* b& t' R3 X( l//使用Install_Handler()注册SWI异常中断处理程序
8 l' E3 R' w! y4 `
. a) G7 H: o& b
4 N) i8 L) P) g/ B; ~# }
( Z) h8 W0 `) a; Q4 E# Junsigned Install_Handler (unsigned routine, unsigned *vector)1 Y/ I+ r% {" }8 O6 v7 T# |
/* Updates contents of 'vector' to contain branch instruction */. n$ H' t, C) i: A. i9 g( ?
/* to reach 'routine' from 'vector'. Function return value is */$ M: |' M0 ~: b/ G- o- S
/* original contents of 'vector'.*/7 ~7 c( W/ T: Y; e# e
/* NB: 'Routine' must be within range of 32MB from 'vector'.*/
' H+ U, |- v7 b* t2 x
! f' u) r+ x/ x3 m/ F+ j" l{   unsigned vec, oldvec;/ h. m, ]9 l- [. L3 Y6 Z
    vec = ((routine - (unsigned)vector - 0x8)>>2);+ L6 B% R" J" C4 M
    if ((vec & 0xFF000000))7 \2 E" a. h- Y! ]( V# `/ j
    {
. a/ d. @/ M, n! k        /* diagnose the fault */$ G: l2 c8 Q  ~# g2 n
        prinf ("Installation of Handler failed");1 }. H0 s2 q# t
        exit (1);
( `6 X0 p4 F% ?/ y+ f. `( F0 C; X    }* N- z$ C! \7 G. ]& C
    vec = 0xEA000000 | vec;2 g, V, z$ O; p
    oldvec = *vector;4 N2 h% W- e2 N9 u) [9 I+ n. l
    *vector = vec;
' h6 {7 h: p7 y8 j1 d    return (oldvec);% H5 g8 B% O- v7 g  d% P
}
& E2 C% M: F. r6 S, W* H& O
+ D6 u8 l# X1 V" F% e : c1 G9 r2 r% ~- y! o

9 g1 t8 h& F/ Y' F& |8 `int main( void )
# o/ }! }  @1 z{& |9 J3 I; n- S- I- M
    int result1, result2;
8 I: k- w4 p& z    struct four_results res_3;
- O0 ?: P3 v4 K  l: L    Install_Handler( (unsigned) SWI_Handler, swi_vec );6 u4 a" u9 Q6 T$ ~) }, f, u
    printf("result1 = multiply_two(2,4) = %d/n", result1 = multiply_two(2,4));
; I( u3 h* j0 B" \. v    printf("result2 = multiply_two(3,6) = %d/n", result2 = multiply_two(3,6));4 q. Y7 }7 g& r0 [2 @
    printf("add_two( result1, result2 ) = %d/n", add_two( result1, result2 ));
# N. r/ r" n  O" v+ X# i: j& r    printf("add_multiply_two(2,4,3,6) = %d/n", add_multiply_two(2,4,3,6));
% S5 g1 b' H+ U8 k    res_3 = many_operations( 12, 4, 3, 1 );
7 r! a* W6 b; @0 U    printf("res_3.a = %d/n", res_3.a );
+ t4 `8 j; `; a6 v8 N    printf("res_3.b = %d/n", res_3.b );8 j, T) j' X, s$ G- R9 ]# F
    printf("res_3.c = %d/n", res_3.c );
6 ~1 M7 y, a0 @1 Z    printf("res_3.d = %d/n", res_3.d );  W# ^0 {1 X; d4 p: w! t6 R
    return 0;4 ]0 c3 |5 i0 B/ J) C& S
}
8 i) N  r- l9 |: Q! Y3 t3 b0 j$ l  l$ j

# g) }( N. v! B$ W# W% d: W9 ^, M* r4 M2 V% K: ^/ `
//第1级SWI异常中断处理程序: G4 Q7 f* t$ Z3 x. `' I& j0 [8 u

$ A/ [& k, n$ N, ]2 C- ]        AREA  LevelOneSWI  ,CODE ,READONLY/ B) |3 B+ z/ X0 o, x" g# B

( E( q3 J3 v7 e9 c# v        EXPORT  SWI_Handler
9 X" f& g9 n- e8 X. O0 u  i4 v! p( y$ ~- k. y6 T
        IMPORT  C_SWI_Handler( ^- s" }/ C$ a( t2 r
$ ~, Q9 P/ k4 w# Y
T_bit      EQU   0X20
7 R' O0 U" Y& f  m/ `9 P! k9 ^5 F( x6 a( |5 [
SWI_Handler% `; c8 U, K+ @+ O) i) j
. |* z# O' R1 {0 ^  R  @
;保存用到的寄存器
% ~" u! ]  w4 E8 P8 L
* [9 e/ b" O+ g! q, J' R        STMFD  SP!,{R0-R3，R12，LR}
$ K1 `) m4 A' \. [0 @8 M1 E$ l! H) ~0 }) Z& r3 X* E
;保存参数* q/ J& }  E. Z3 G( p: j$ C

0 t! {8 e2 Y  ~1 K: P        MOV R1,SP. s0 w1 Z/ }2 U

. E0 x# y9 L# \+ y' J;保存SPSR& a  M0 E5 q5 S* G

- s/ J7 {( x' U1 k        MRS  R0，SPSR( X( {( W& B+ r
4 L6 k+ {7 l  D! W) l
        STMFD SP!,{R0}1 u8 t$ f9 G* Y3 [+ [' J
6 @5 W  [4 J9 n- L) C- ~
        TST   R0, #T_bit
% ~! x8 l* |! ?% V9 K$ W. x8 K, z: }4 M
;如果为thumb状态
( _# w9 C5 H1 E" n0 g
. ?7 j9 |6 Q6 C* u        LDRNEH  R0，{LR,#-2}
" t% o0 g  ^; x. ^- [& e* i3 V* k! a6 G7 ~$ Y+ ?6 j
        BICNE   R0，R0,0XFF00( U; E' d9 n4 r

1 B% E- V4 ~8 s- R;读取SWI指令
9 v- ]3 Q7 ?$ V( Y7 ~$ Q# Q6 x6 H8 H* \, S. L* h9 A% `  b
        LDREQ  R0,{LR,#-4}5 T+ ^3 P1 L1 o) e: p  F0 N8 U$ R4 P
2 e9 W! {# Y1 D' }1 V/ J
;计算其中24位的立即数，并把其放入R0- u8 T( q" f0 q1 p7 L" r- C

8 e' D% f. a0 N1 S% U7 V6 X       BICEQ  R0,R0,0XFF0000003 e( {; o2 D9 a8 ~
" F) _6 B! S$ f
;调用C_SWI_Handler
  j/ \/ F- N& _7 b  r% x" r3 c/ F7 m4 a1 ~
       BL C_SWI_Handler
+ T( m: R) e" y) V+ o) I/ ?7 S  Q5 w0 b& G9 D% Q+ k- [6 Z- c% o# |
;恢复SPSR_svc
. m+ @. n2 u: i: u5 R$ a1 c* p  c; {9 p; U# W' m' o( R6 Z! y
       LDMFD SP!,{R0}2 o" \! [5 L0 x9 V9 Q% x+ C  X% H6 {
2 J3 l- ^# q2 d/ ~9 R! R% [
       MSR   SPSR_svc, R0- o3 o5 Z# v) m) h9 I/ n" O7 @
% D0 m. W; q% ?
;恢复其他寄存器，包括寄存器LR_svc
; ]( ], ?9 j6 J, m" V; G" D' ]* Q8 o+ K  `( x- s/ t: x4 C
       LDMFD  SP!,{R0-R3，R12,PC}^+ S/ ?; n# d4 \4 o& C8 I
8 E: ]& l* E% n$ ?8 i
       END
$ n, e: j5 q7 [% A
4 _; m5 S4 _" n" k4 c
2 X" W- c' w  n) ^  I" c! ^9 o8 ^; O, a. N7 a- G8 @: M" [% O
;第2级SWI异常中断处理程序
0 ~* J" G$ l: L
7 w* {& X' j- _7 ]4 d5 tvoid  C_SWI_Handler (unsigned swi_num,int *regs)" V  m* a1 Z6 R5 B$ J/ _% `/ J
% ?1 ?; @8 L8 u9 `8 _
{
& l; @3 }) e/ ?1 `2 A; N      switch  (swi_num)+ X# m5 l, G6 G" u

9 H& F6 l: U8 ?( s( T. e      {' S8 z( t  V. T% a
         case 0:
" f1 J+ }1 ?( r  `
6 r# ?( f% w! f+ I  K, U                   regs[0]=regs[0]*regs[1];. G; h% ?3 I, I! `

5 u0 T2 _3 o7 X! S$ w5 _4 w        break;
2 h: {9 K5 s: _+ {# x, y* z" E4 p, W2 _
         case 1：: @' e0 F$ j( ^& x+ x% Z
& y5 t' S. X7 Y3 f/ R, E
                   regs[0]=regs[0]+regs[1];
# Y8 o+ W" \( G2 ?& i, B
8 `0 Y" s% T1 O. Z5 a3 G: U/ R        break;2 s% ^4 P* ?; O; n9 A2 {. W8 R
* h  r; t% ]' r. H+ A6 y+ c1 \
         case 2：$ m6 l$ r, E! _, Z6 d$ l& ]
2 I5 N' h# D" U* H& S1 i
                   regs[0]=(regs[0]*regs[1])+(regs[2]*regs[3]);
/ C3 @" t" \0 D& r8 R0 v, w1 B
' T# h0 w) v- f4 t        break;5 x! z& ?8 i" k0 h8 K

) P' O* f4 O9 E9 a/ H         case 3：
' O& q( l* T* x5 |) C- l  G) ?9 b9 q! b6 J. h5 b( L4 d& ^
          {
; L( e4 D6 `2 B              int w,x,y,z;. \, a+ N* f/ J; N( x1 F

6 O' S7 O' w- f$ l! s9 t$ T              w=regs[0];
4 `! z- t7 K# `6 @2 P4 e. s- O+ M. X. d
              x=regs[1];
. z# c) F0 `1 g3 K( x6 y' o! I# X0 X: M* Y5 P. }
              y=regs[2];0 H+ Q, N, r: W2 U( l
" f3 y5 N6 l. U, T+ w! A
              z=regs[3];
/ r1 _9 ~, ?7 k5 t" b* V$ g& R6 b

! U: t& y: L6 b: w5 U. |
+ T' m) w4 L, r/ Y! g# U. `$ o              regs[0]=w+x+y+z;
+ s+ T; Q3 Q' q( r9 ~) i0 v% u) j: u0 S
              regs[1]=w-x-y-z;" _4 `3 m1 |: b! v& a+ d. C0 p9 j

% z2 V" ^. \6 o, w              regs[2]=w*x*y*z;
# X) {" P4 R5 d. ?- `7 o: X* K0 ~$ U3 m) i
              regs[3]=(w+x)*(y-z);
% E, y  M! r7 r& y5 `: Z7 A0 [& p- U, R6 i6 v" h0 V
            }% j: c2 B5 M$ v! c0 p+ ]
/ R8 s1 e* [# {1 p- U
          break;
( P2 X0 n/ r. `7 @/ N! L9 {7 k8 r; n) P* @; Y% I1 Y% l( Y9 A
        }! w1 Y4 d! X' @- |2 j) Q4 w( ^
  O  H' ?9 \6 R0 n3 {
}
+ n0 ^  ~2 _" z& i6 c$ J0 a) B- Y; a. L: n2 t

/ @- t6 V4 \8 ^& k% u. j! Q0 r% [& O' j9 b, c  p
3应用程序动态调用SWI; N0 E/ [6 j( t
; z4 F% ]0 P. N5 S- B& \6 L
#ifdef __thumb' r% _# q. `; P: H2 O0 n6 z
/* Thumb Semihosting SWI */* H4 Y8 J, v7 k: P6 [' g
#define SemiSWI 0xAB) v2 ]" Q' L- o+ T6 I; p& H4 o* T
#else
+ d. T" M4 ?0 B& N; F4 Q! q. W/* ARM Semihosting SWI */
& p2 W* `  d) D#define SemiSWI 0x123456
" Z; Q6 F2 A& f0 G: W7 Y) S/ p#endif7 e$ H; v- ~4 B' m' G% |
( v/ f5 d' g2 h( Q' @/ a
/* Semihosting SWI to write a character */ + x2 D5 y& Q0 w% J5 R
__swi(SemiSWI) void Semihosting(unsigned op, char *c);
2 E0 G, B+ H* h1 g#define WriteC(c) Semihosting (0x3,c)
  m. C8 Z$ _2 T  F$ K  Z
  o: B' R9 H4 u8 H2 bvoid write_a_character(int ch)
4 W" `3 y( x+ h6 ?8 t{
6 D  ^+ n) ~: O" M* v/ O    char tempch = ch;) m: h. g  ?5 t+ M; F
    WriteC( &tempch );
  m# Y/ ]2 L1 C}
# b4 q+ v# S' h1 z9 k4 D9 J6 h; h2 A& P$ k& U7 U
/ y8 [5 E0 H3 i; ^2 N6 u
作者: NingW    时间: 2021-2-5 10:56
ARM体系结构与编程学习
作者: updown    时间: 2021-2-5 10:57
ARM体系结构与编程学习，不错，挺基础的。先收藏了。



欢迎光临 EDA365电子论坛网 (https://bbs.eda365.com/) Powered by Discuz! X3.2