이번 절에서는 ARM 명령어중 데이터 처리 명령어를 알아보겠습니다.
가 있습니다. 일단 산술명령어는 2진 덧셈, 뺄셈을 뜻합니다. 이때 오퍼랜드는 32bit를 사용하고 부호를 사용하지 않을수도 있고 부호를 사용한다면 2의 보수체계를 사용합니다. 비트논리 연산명령어는 두개의 오퍼랜드의 비트를 연산하는 명령어입니다. 예를 들어 11 곱하기 23을 일반적으로 하면 230+23이 되어 253입니다. 하지만 비트연산을 하면 11을 2진수로 표현하면 레지스터 이동 명령어는 두번재 오퍼랜드를 첫번재 오퍼랜드로 이동시키는 명령어 입니다. 예를 들어 비교명령어는 연산을 하지만 결과값을 레지스터에 저장하는 것이 아니라 CPSR의 Condition flag만이 update된다. 여기서 ARM CPU만의 특징이 하나 더 나오는데 그것은 바로 Default flag update가 안된다는 점이다. 보통 cpu들은 이런 연산을 할 경우 명령어에 특별한 명령을 더 하지 않아도 flag가 update된다 하지만 ARM CPU에서는 ADD를 하더라도 ADDEQ 와 같은 뒤에 명령어를 더 붙여줘야만 flag가 업데이트 된다. 이번에는 시프트된 오퍼랜드에 대해 살펴 보겠다. 이 ARM 명령어 세트 형식을 보면 두번재 소스의 코드 길이가 12bit나 된다. 왜 이렇게 많은 bit를
할당해놨을까? 그 이유는 ALU의 shifter에 있다.
아까 지훈이가 물어봤을때 헷갈려서 대답을 못해줬는데 일단 ADC와 SBC가 뭔지는 다들 알거야 SBC = OP1 - OP2 + C - 1 이라고 되어있지 일단 이걸 알아내려면 왜 더하기와 빼기에 캐리가 더해지는 연산이 필요할까 일단 위의
식에서의 C는 캐리가 맞아 8비트 ADDER를 만들 경우 4비트 ADDER 2개를 이용해서 만드는 방법이 있는데 예를 들어보면 어떤 64비트의 값을 R0와 R1에 넣고
이와 마찬가지로 SBC도 설명이 되지 AREA EX_C, CODE, READONLY MOV R0, #1 SUBS R2, R1, R0 SUBS R4, R0, R1 END 참고로 위의 소스에서 R0-R1을 할 경우 캐리가 발생하지 않고
ARM Instruction Set�� ARM ���ɾ�� �� �������� �̾߱� �ϴ� ���Դϴ�. ��κ��� C �ڵ带 �̿��ؼ� �۾��� �մϴٸ�, �������� ��������� �����ϰ� �־�� �ϴ� ��� ������ �ֽ��ϴ�. �Ϲ����� ARM ��������� ���� �Դϴ�.
- Directive : ������� �ڵ��� Ư���� �����ϴ� ���þ� �Դϴ�. 7.2 ARM Instruction sets ARM Processor�� 2���� ���ɾ� ��Ʈ�� �����ϴµ� 32bit ARM ���ɾ�� 16bit Thumb ���ɾ �ֽ��ϴ�. Thumb ���ɾ�� ��� ARM ���μ������� �����ϴ� ���� �ƴϰ� Thumb Ư���� �����ϴ� Core������ ����� ���� �մϴ�. �ֱ� Cortex �迭������ 16bit, 32bit ���ɾ ���� ����� �� �ִ� Thumb-2 Instruction�� ���� �մϴ�. ������ Cortex-M3�� ��쿡�� Thumb-2 Instruction�� ����� ���� �մϴ�. 8bit ������ Jave Byte Code�� ��� �� �� �ִµ� �̰͵� Thumb ���ɾ�� ���� ��� ARM Processor�� �����ϴ� ���� �ƴմϴ�.
7.3 Data Processing Instructions (1) Instructions
< Cond > < I > < Opcode >
< S > S ��Ʈ�� 1�� ���� ������ ���μ��� ������ ����� CPSR�� ����(Rd�� �������Ͱ� PC�� ��� SPSR�� ������ CPSR�� ����)�� ��Ĩ�ϴ�. ��, 0�� ��쿡�� CPSR�� ������ �ʽ��ϴ�. < Rn > < Rd > < Operand 2 > (2) Syntax : <operation>{cond}{s} Rd, Rn, operand2 - Operand2 is a register - Operand2 is immediate
value - Operand2 shifted value - Data movement - Comparisons set flags only (3) Immediate value
Immediate value(��� ��)= ROR immed_8 by 2*rot MOV R0, #0xFF000000 ���� �������� ��� ������ "#0x104" �� ����� �� �ִµ� "#0x102", "#0x12345678" ������ �ü� ���� ������ ���� �ϱ��?
�Ʒ� Immediate value�� �� �ٸ� ���� �Դϴ�. (4) 32-bit Instruction format MOV R0, #1 ������ �ܼ��� ���� �ε���. ������ ��� 32-bit Instructions ������ �м��� ������ �ϰڽ��ϴ�. �ڵ带 Disassebly �غ���
Instruction ������ �ٽ��ѹ� ���� ���� �Ʒ��� �����ϴ�.
[31:28] : 1110 - 7.11 Conditional Execution ���� ��� ���� �Դϴ�. �켱�� �׳� "1110" �� Always execution flag ��� �˾� �νñ� �ٶ��ϴ�. * ���� (5) Examples R0 = 0x00 ���������� ������ ���� ������ �Ʒ� �������� ���ʴ�� ���� �������� ������ �������� ���� ? AND R0, R0, #0xFF ; 0x00 & 0xff = R0�� ���� ��ȯ ����
ADD R0, R0, #1 ; R0 = R0 + 1 = 0x1
ADD R0, R0, R1 ; R0 = R0 + R1 = 0x01 + 0x22 = 0x23
LSL R1, R0, #2 ; 0x23(100011) LSL #2 = 0x8C(10001100) -> ������ �������� 2�� ����Ʈ �ϸ� *4 �� �ѰͰ� �����ϴ�.
SUB R3, R2, R1, LSR R2 R3�� ���� 0xFFFFFFDF �� ������ ���� ���Խ��ϴ�. �� �̷� ����� ��������� ? 0x21 = 00000000000000000000000000100001 ������ 2�� ������ ���ϴ� ����� ������ 2�������� 0->1, 1->0 ���� �ٲ��Ŀ� 1�� ���ϸ� �ǰ�����.
BIC R0, R1, #0xFF00 R1(0x8C) = 0000000010001100
RSB R0, R1, #0 ; #0 - R1(0x8C) = 0xFFFFFF74(0x8C �� 2�� ���� ��) RSB ���ɾ�� SUB�ʹ� �ݴ�� ���̳ʽ� ������ ���� �մϴ�.
7.4 Multiply Instructions (1) Multiply (Accumulate) Syntax (2) Examples R0 = 0x01 ���������� ������ ���� ������ �Ʒ� �������� ���ʴ�� ���� �������� ������ �������� ���� ? MUL R2, R0, R1 ; R2 = R0*R1 = 0x02
MULS R2, R0, R1 ; R2 = R0*R1 = 0x02 MUL ���ɰ� ���� �����Դϴ�. ������ MUL�ڿ� "S" �� ������ ���ɾ� ó���� ���� ���Ŀ� CPSR�� Flag Field �� ���� ����� ���� ������Ʈ�� �˴ϴ�.
MLA R3, R2, R1, R0 ; R3 = R2*R1 + R0 �� ȿ�����̳�. ���ɾ� �ϳ��� ���ϱ� ����� ���ϱ� ������ ���� �� �� �ֽ��ϴ�.
SMULL R3, R2, R1, R0 ; R3,R2 = R1*R0 ��ȣ�ִ� 64��Ʈ ���� ���ɾ� �Դϴ�. R1*R0 �Ͽ� ���� 32��Ʈ�� R2�� ���� 32��Ʈ�� R3�� ���� �մϴ�.
������ ��ȣ�ִ� ������ ���Դµ�, ���� ������ ������ Ǯ�� ������ �ϰڽ��ϴ�. R0 = 0xF0000002 �ʱ� ���������� ���� ���� ������ SMULL ���� ������ R2, R3 �� ���� ��� �ɱ�� ? �켱 0xF0000002�� ���� �̱� ������ ������ �ϱ� ���ؼ��� 2�� ������(F0000002�� 2�� ���� = 0xFFFFFFE)�� ���� ���մϴ�. ���� ���� 0xFFFFFFE * 0x02 = 0x1FFFFFFC �� �մϴ�. ������ ������ ���� ������ ǥ���ϱ� ���ؼ� �ٽ� 0x1FFFFFFC �� 2�� ������ ���մϴ�. �̶� SMULL�� 64��Ʈ ���� ���ɾ� �̹Ƿ� 64��Ʈ�� Ȯ�� �մϴ�. �̷��� �ϸ� ���� 32��Ʈ�� 0xFFFFFFFF �̰� ���� 32��Ʈ�� 0x04�� �˴ϴ�.
���� ������ "MOV R0, #-268435454" ��� R0�� �ʱ�ȭ �ϰ� �ֽ��ϴ�. �̰��� 0xf0000002�� ���� ����(�ֻ��� ��Ʈ�� 1�̸� ��������)�̱� ������ �����Ϸ����� �˱� ������ ���� 10������ ǥ���� ���ذ� �Դϴ�. 7.5 Load/Store Instructions Memory�� ������ �������ͷ� �̵�(Load)�ϰų� ���������� ������ �� ����(Store) �ϴ� ���ɾ� �Դϴ�. ������ Access������ ���� �Ʒ��� ���� �з� �˴ϴ�. Load, Store�� ARM ���ɾ� ��� ���� ���� ���Ǵ� ���ɾ� �̸� ������ �߿��մϴ�. �ݵ�� ���� �ϰ� �־�� �մϴ�. - Word : LDR, STR (1) Syntax (2) Addressing Mode - Pre Index : Rd �������Ϳ� ������ ���� �̵���Ų �� <address> offset�� ���� Ȥ�� ���� �մϴ�. R0 = 0x31000000 ���������� ����� ��(�� �迭�� ��Ʋ �����) ���� ���� ������ �Ʒ� �������� ���ʴ�� ���� �������� ������ �������Ϳ� ���� ���� ? LDR R1, [R0] ; R1 <-- M[R0] R0�� ����Ű�� �ִ� 0x31000000 ������ �� ���� 0x67452301 �Դϴ�. ���Ƿ� LDR ���� ���Ŀ� R1���� 0x67452301 ���� ���� �˴ϴ�.
STR R1, [R0, #4] ; R1 <-- M[R0+4] R0�� ����Ű�� 0x31000000 �������� 4-byte �� ���� ������ �� ��ġ�� R1(0x67452301) ���� ���� �մϴ�.
STR R1, [R0, #4]! ; R1 <-- M[R0+4], then R0 <-- R0+4
R1�� 0x31000004������ �� ���� 0x67452301�� �����ϰ� �� ���Ŀ� R0�� �������Ͱ� + 0x04 �� ���� �մϴ�.
- Post Index: Offset calculation after data transfer R0 = 0x31000000 ���������� ����� ��(�� �迭�� ��Ʋ �����) ���� ���� ������ �Ʒ� �������� ���ʴ�� ���� �������� ������ �������Ϳ� ���� ���� ? LDR R1, [R0], R2 ; R1 <-- M[R0], then R0 <-- R0+R2 R1�� R0 �� ����Ű�� 0x31000000������ �� 0x67452301�� ���� �����ϰ� ���� R0 = R0(0x31000000) + R2(0x04) �� �˴ϴ�.
STR R1, [R0], #4 ; R1 <-- M[R0], then R0 <-- R0+4
�������� R1�� �� 0x67452301�� �� 0x31000004 ������ ������ �ϰ��� ���Ŀ� R0 = R0(0x310000004) + 0x04 �� ���� �մϴ�.
(3) Literal Pool MOV R0, #0x12345678 ; illegal (build error) ���� �������� 0x12345678 ���� LDR ���ɾ ����ϸ� ���� ���� ����� ������ ���� �˼� �ֽ��ϴ�. LDR���ɾ ����ϴ� ���� ���غ��̱�� ������ �� �����ϱ� ������ �ӵ��� ���� ������������.. 7.6 Load/Store Multiple Instructions LDR, STR ���ɾ�� ����� ���� ������ Rn�������� ���� ����Ű�� �� ��ġ�� ������ �������� ������ ���� �� �� �ֽ��ϴ�. (1) Syntax (2) Addressing Mode (3) Examples * �������� ���� R0 = 0x000A R4 = 0x000B R5 = 0x000C R13 = 0xFFF0 STMIA R13!, {R0,R4-R5} ������ ����� ?
STMIB R13!, {R0,R4-R5} ������ ����� ?
STMDA R13!, {R0,R4-R5} ������ ����� ?
STMDB R13!, {R0,R4-R5} ������ ����� ?
������ ARM Compiler�� Stack ���۽� Full Descending Stack ������� ���� �ϰ� �ֽ��ϴ�. STMDA ���ɾ�� ������ ��� �Դϴ�. �� Stack Pointer�� �� ��ȿ�� ������ ����Ű�� �ְ� �ּҰ� �����ϴ� �������� ������ �˴ϴ�. - Stack ���� PUSH, STMDB ��ſ� �Ʒ��� ���� ����� ���� �մϴ�. - Stack ���� POP, LDMIA ��ſ� �Ʒ��� ���� ����� ���� �մϴ�. "^" �����ڴ� �������� ��������(Rd)�� PC�� ��쿡 SPSR�� CPSR�� �ϱ����� �϶�� ���� �Դϴ�. 7.7 Branch Instructions Ȥ�� ���� �Լ��� ���� ���ν����� �������� �˰� �ֳ��� ? 2���� ��� ���� ���α� �帧���� ����(�б��Ͽ�)�� Ư�� �۾��� �����ϴ� ���� ���� �մϴ�. ������ �����ϰ� �������� �̾߱� �ϸ� ���� ���ν����� �б� ���Ŀ� �б��ϱ� ������ �帧���� �ǵ��� ���� �ʰ� �б��� �ּҿ��� ���� ���α� ������ ��� �� ��쿡 ����� �ϰ� ���� �Լ��� �б��� �ּҿ��� Ư�� �۾��� �����ϴٰ� �б� ������ �ּҷ� �����Ͽ� ���α��� ���� �ϵ��� �մϴ�. ������ ��� ����. ���� ���ؼ� �������� ������ ������ �սô�. * ���� ���ν��� ȣ��� ���α� �帧 * ���� �Լ� ȣ��� ���α� �帧
(1) Syntax - ���⼭ PC�� Pipeline ���� ���� �ߵ�� Branch Instruction �� �ּҿ��� 8�� ���� ��ġ�� �˴ϴ�. (2) Branch Range �б� ������ +- 32MB ������ ������ �Ǵ� ������ 2^24 = 16MB << 2 �� �ϸ� 64MB �̰� �̸� +- �� �ϸ� 32MB ������ �Ǵ� ���Դϴ�. (3) Examples LDR PC, =func ������ LDR ���ɾ ����ϸ� Branch���ɾ ������������� 1���� ������ �ִµ� 4GB�̳������� ������ �бⰡ ���� �ϴٴ� ���Դϴ�. Branch ���ɾ��� �б� range�� -32MB ~ +32MB�� ������ �ֽ��ϴ�. ���� ���� �ּҸ� �о�;� �ϹǷ� ���ɸ鿡���� ���� �ʰ�����. (5) �Լ� ȣ��(BL) - ARM ��� �Լ� ����� - Thumb ��� �Լ� ����� (6) Subsequent Function Calls
���� �������� �����Լ��� ȣ���ϰ��� ���Ŀ� main ��ƾ�� �ִ� R2���� #3�� ������ �Ǿ� �־�� �մϴ�. ��� ��� #11�� ������ �Ǿ� ������ �����ϴ�. R0, R1�� func1���� ���� #3, #4 �� ������ �ǰ� func2�� ��ġ�鼭 #5, #6�� ������ �˴ϴ�. ���� #11�� �ɰ��̶�� ������ �ɼ� ������ ����� func1�� ADD ���ɾ �ݺ��ؼ� ������ �ɰ��Դϴ�. �ֳ��ϸ� main���� func1���� branch�Ҷ������� LR���� BL���ɾ� Address+4 �� ������ �ǰ� func1���� func2�� �б� �Ҷ� �ٽ� LR���� func2�� �б��ϴ� BL���ɾ� Address+4�� ������ �Ǿ� ���� func2���� MOV PC, LR �� ������ �ϸ� func1�� ADD ���ɾ�� PC�� �̵��� �ϰ� �ٽ� func1���� MOV PC, LR �� ������ �Ǹ� LR ���� ���ؼ� �ٽ� func1�� ADD ���ɾ �ݺ��ؼ� ������ �ɰ��Դϴ�. ���� �����ѵ� ������ �� ���� ���� �� �� �ֽ��ϴ�. �� �������� �˼� �ִ°��� ���� �Լ��� ȣ���� ��쿡�� �����Լ������� �ݵ�� LR�� �����Լ����� ����� �������͵��� Stack�� ����� �ϰ� �����Լ����� �������� �ٽ� Stack���� ������ �ؾ� �Ѵٴ� ���� �� �� �ֽ��ϴ�. ���� ���� ������ main ��ƾ�� �ִ� R2�� #3�� ������ �ǵ��� ������ �ϸ� ��� �ɱ�� ?
���� ������ MOV SP, #98304 �� �ϴ� ������ Stack�� ����ϱ� ���ؼ� Supervisor ����� Stack ������ �ʱ�ȭ �ϴ� ���Դϴ�. ������ Stack �������� �ּҴ� ���� Ÿ�ٸ��� �ٸ� �� �ֽ��ϴ�. Stack �����ʹ� �ַ� �ý����� �� �� ��ġ �մϴ�. (7) Veneer
���� ��� �̿ܿ��� �߰��� �Ʒ��� ���� ����� �ֽ��ϴ�. - ARM to ARM or Thumb to Thumb ���� �б� : Long branch capability 7.8 Status Register Access Instructions (1) Syntax MSR{cond} CPSR_<fields>, #<immediate> �������� ���� ������ CPSR ���������� ������ �ٽ��ѹ� Ȯ�� �ٶ��ϴ�.
(2) Examples - IRQ �� Enable �ϴ� �ڵ� �Դϴ�. �Ʒ� ���ɾ� ���� ����Ǵ� ������ CPSR���������� ��ȭ���� Ȯ���� ���ñ� �ٶ��ϴ�. MRS R0, CPSR
BIC, MSR ���ɿ� ���ؼ� CPSR�� I �� "0" ���� ����(Unmask) �Ǿ� Interrupt�� �����ϰ� �Ǿ����ϴ�. ������ CPSR_fc �� CPSR�� ���� �������� �Դϴ�.
- IRQ �� Disable �ϴ� �ڵ� �Դϴ�. ��Ȥ MSR_c, MRS_x ������ ���Ǵ� �������� �ִµ� ���� ������ ���� flag�� �ǹ̴� �Ʒ��� �����ϴ�. ���� ���� ������ _c, _x ���� �ǹ̸� ��Ȯ�ϰ� �ϱ� ���ؼ� ����ϴ� ���ϻ� �����ص� �ƹ� ������ ������ �ʽ��ϴ�. (1) Syntax SEI ���ɾ�� S/W ������ ���������� ARM�� IRQ ���ܸ� �� ��ŵ�ϴ�. �ַ� OS���� User application���� �ü�� ���� ��ƾ�� ȣ���� ��쿡 Ư�Ǹ�忡�� ���ϱ� ���ؼ� ���� ���˴ϴ�. (2) Examples 7.10 SWP Instruction (1) Syntax (2) Operation (3) Semaphore Instruction (4) Examples R0 = 0x01 ���������� ������ ���� ������ �Ʒ� �������� ���ʴ�� ���� �������� ������ �������� ���� ? SWP R0, R1, [R2] R2 �� ����Ű�� �ּ�(0x31000000)�� �� 0x78563412�� ���� R0�� ������ �Ǿ���,
R1�� �� 0x02�� R2�� ����Ű�� 0x31000000 �� ������ �Ǿ����ϴ�.
�Ʒ��� ���� ����Ʈ ���ɾ� �Դϴ�. SWPB ���ɾ ������� ��� R0 ���� � ���� ������ �ɱ�� ? SWPB R0, R1, [R2]
������ SWP�� �����ϰ� ���� ����Ʈ ������ SWP�� �ȴٴ� �� �ٸ��ϴ�. ���� ������ ���� �Ͻñ� �ٶ��ϴ�. 7.11 Conditional Execution ARM��� ���� ������ ������ ������� ���ɾ���� Ư�� ������ �������� ������ ���� ��ų �� �ֽ��ϴ�. �̷��� ���Ǻ� ������ �����ϸ� ���ɸ鿡�� �Ʒ��� ���� ������ �ֽ��ϴ�. - Increase code density Thumb��忡���� �б���ɾ� �̿ܿ��� �� ���Ǻ� ���� ����� ����� �� �����ϴ�. �� ������ ���ɾ��� ���̰� Thumb ��忡���� 16bit�� ������ �Ǿ ���Ǻ� ������ �Ҹ�ŭ �������� ������ ������� ���ϱ� �����Դϴ�. ���� ���� ������ �����̶��
���� ��͵��� �������?
< Cond > ARM ���ɾ��� ���̴� 32bit��� �Ͽ����ϴ�. 32bit�߿��� 4bit�� ���Ǻ� ������ �ϴµ� �Ҵ��ϰ� �ֽ��ϴ�. [31:28] bit��
�ٷ� <Cond> ��Ʈ �Դϴ�.
������ �츮�� ���ݱ��� ����� �Դ� MOV, ADD ���ɾ� �ڿ� Mnemonic ���� ����� �ϸ� "Always" �� ����Ǿ ������ �� ���Դϴ�. (1) Condition Flag Change Condition Flag������ Data Processing Instructions �� ���ؼ��� ������ ������ ���ɾ� �ڿ� "S" Prefix�� ����ؾ߸� �մϴ�.
������ ���� �����Ѱ���. ������ ���ؼ� ���� ������ �սô�. (1) Examples1
- N : ������ ��� R2(0x40000000)�� �ֻ��� ��Ʈ�� "1" ��
�ƴ�
- N : ������ ��� R2(0x00000000)�� �ֻ��� ��Ʈ�� "0" �̹Ƿ� Negative ������ ����
- N : ������ ��� R2(0x80000000)�� �ֻ��� ��Ʈ�� "1" �̹Ƿ� Negative �� (2) Examples2 ADD R0, R1, R2 -->
does not update the flags( "S" Prefix �� ���� )
SUBS R2, R1, R0 -- SUBS ���� ���� ���Ŀ� CPSR�� condition flag�� ������Ʈ �˴ϴ�. ������ CMP, TST, CMN, TEQ instructions ���� ��, �˻� ���ɾ� ���� "S" Prefix �� ���̵� CPSR�� condition flag �� ������Ʈ �Դϴ�. ���� ������ Conditional Execution�� ������� ���� ������ ���� �����ؼ� ���� ������. if(a==0) a = a + 1;
���Ǻ� ������ ��������μ� instructions �� 2���� �ٿ��� ���� �߿��� ���� branch ���ɾ��� ������ �ߴٴ� ���Դϴ�. branch ������ ARM pipeline�� ���ʶ߸��� ������ ���ɿ��� ������ ġ�����Դϴ�. 8. Thumb Instruction Sets 8.1 Thumb Instruction Ư¡
8.2 Thumb Instruction ���� ���� - Limited Access to Registers : R0-R7 registers are accessible. 8.3 Thumb, ARM Instruction �� �Ʒ� �ڵ带 ARM ���ɾ�� Thumb ���ɾ�� �ۼ��ϰ� ���� ���ñ� �ٶ��ϴ�. if(x>=0) return x;
���� ǥ���� 16-bit bus �ϰ���� access Ƚ���� ���� ������ Thumb ���ɾ ȿ���� ���̱ �մϴ�. 8.4 ARM/Thumb Interworking ARM ���� Thumb ��带 ���� ��� �� ���� �ֽ��ϴ�. ������ ���ÿ� ���ɾ� ���� ��� ����� �� �ִ°��� �ƴϰ� ARM ��忡�� BX branch���ɾ ���ؼ� Thumb ���� ��ȯ�� �Ҽ��� �ְ� �ٽ� Thumb ��忡�� BX ���ɾ �̿��ؼ� ARM ���� ���� �� �� �ֽ��ϴ�. (1) BX Instruction BX���ɾ�� �Ϲ� �б���ɾ�� ����Ѱ� ������ ���� �ٸ��ϴ�. ������ 32bit ARM ��忡�� Thumb ���� ��ȯ�� �Ҷ� 32bit ���ɾ� ���� 16bit �� ����Ǹ鼭 PC�� �ּ� �����ϴ� ���� 4byte���� 2byte�� �ٲ�� ������ �� ���Դϴ�. �翬�� Thumb ��忡�� ARM ���� �ٽ� ���� �Ҷ��� �ݴ��� ��� �̰���? ���� ����� ? ���� �� ���� �ϵ��� �ϰڽ��ϴ�.
���� ������ ���� �ڽ��� �� ���ø� armcode �κ��� 32��Ʈ �ڵ� �������̰�,
thumbcode �κ��� 16��Ʈ ������ �ڵ� ���������� �� �� �ֽ��ϴ�. thumbcode �� ���۵Ǵ� �ּҴ� 0x6C �ε�, armcode�� "BX, R0(0x6d)" �ڵ忡 ���ؼ� 0x6C�� �ƴ� 0x6D �� �б� �϶�� �Ǿ� �ֽ��ϴ�. �ùٸ��� ������ �ɱ�� ? ���� �� ������ �˴ϴ�. �̰��� ����� ������ ������ "CPSR.T <-- Rm[0], PC <-- Rm & 0xFFFFFFFE" �� �ֽ��ϴ�.
9. AAPCS ���� �̾߱� �ϸ� ARM���� ���� ��ƾ�� ȣ���Ҷ��� ��������, ���� ��� ����� ���� ���Դϴ�. �Ʒ� ǥ�� Procedure call�� ���Ǵ� �������͵��� ǥ�� ������ ���Դϴ�.
* ������ scratch register���� �����ƾ ȣ��� ������ ���� �� �ִ� ������ �ִ� �������� �Դϴ�. ���Ƿ� �����ƾ ȣ��� Stack�� ����� ���� �����ƾ�� ȣ�� �ؾ� �մϴ�. ���� ǥ���� �˼� �ִ� ���� �Լ��� ȣ���Ҷ� �Լ��� ���� 4�� ������ r0 ~ r3�� ������ �Ǿ� ȣ���� �ǰ� �Լ� ���� return�� ���� ��� ���� r0�� ��Ƽ� �Լ��� ȣ���� ���� �Լ��� ���� �����ϰ� ������ �˼� �ֽ��ϴ�. �� �Լ��� ���ڰ� 4�� �̻��� ��쿡�� ��� �Ǵ� ���ϱ��? 5��° ���� ���ʹ� Stack�� �������� �Լ� ���� POP�ؼ� ����մϴ�. Stack�� ���� �� ����ϹǷ� �����ϸ� �Լ� ���ڴ� 4�� ������ ����ϴ� ���� ���� ��� ������ �˴ϴ�. void main(void) // R0 �������Ϳ� a+b+c+d+e �� ���� ����Ǿ� return�� �˴ϴ�. int a --> R0 int func1(int a, int b, int c, int d, int e) ���� C �ڵ带 Disassembly �غ��� ������ �����ϴ�. ������ ������ ���� �Ͻñ� �ٶ��ϴ�.
|