[08] ASM1

Moving data (데이터를 옮기기) : CPU와 Mem 사이, CPU-CPU

movl source, dest

~복사

 

● Move 4B("long") word

- intel 32b 기준

그냥 mov는 16b

 

Operand types

1) Immediate

- constant integer data 상수값(C에서는 숫자값, Intel 어셈블리어는 $로 시작)

- 1,2,4B로

2) Register

- 8개의 범용 R중 하나

- %esp, %ebp는 스택을 나타내기 위해 특별한 용도로 사용

3) Memory

- 4 consecutive bytes of memory

- address

 

 movl operand combinations

- Cannot do memory-memory transfers with single instruction : 1 Mem->CPU, 2 CPU->Mem

movl Imm Reg

movl $0x4, %eax    // eax에 0x4라는 값 집어넣기, CPU에 값 저장

temp = 0x4;  // C에서 temp가 eax R쓴다고 가정할 떄

movl Imm Mem

movl $-147, (%eax)    // eax가 가리키고 있는 메모리에 -147 넣기, Mem에 값 저장

*p = -147;  // p가 가리키는 곳으로 가서 

※ (%eax) : eax R가 메모리의 위치를 갖는데, 그 곳으로 쫓아가서 바꿈 ;;eax 메모리의 위치

movl Reg Reg

movl %eax,%edx

temp2 = temp1;

movl Reg Mem

movl %eax,(%edx)

*p = temp;

movl Mem Reg

movl (%eax),%edx

temp = *p;

 

 

 

Simple Addressing Modes

> Normal (R) 

Mem[Reg[R]]
• Register R specifies memory address 

• e.g., movl (%ecx), %eax

> Displacement D(R) 

Mem[Reg[R]+D]
• Register R specifies start of memory region 

• Constant displacement D specifies offset 

• e.g., movl 8(%ebp), %edx

 

Indexed Addressing Modes (1)

Most general form:
D(Rb, Ri, S) Mem[ Reg[Rb] + S * Reg[Ri] + D ]
• D: constant "displacement": 1, 2, or 4 bytes 

• Rb: Base register: any of 8 integer registers 

• Ri: Index register: any, except for %esp & %ebp 

• S: Scale: 1, 2, 4, or 8

Special cases
• (Rb,Ri) Mem[Reg[Rb]+Reg[Ri]] 

• D(Rb,Ri) Mem[Reg[Rb]+Reg[Ri]+D]

• (Rb,Ri,S) Mem[Reg[Rb]+S*Reg[Ri]] 

• D(Rb,Ri,S) Mem[Reg[Rb]+S*Reg[Ri]+D] 

• Useful to access arrays and structures

 

- 계산할 때 D 빼먹지 않기

 

Ex)

%edx 0xf000
%ecx 0x0100

		address
0x8(%edx)	0xf000+0x8	0xf008
(%edx,%ecx)	0xf000+0x0100	0xf100
(%edx,%ecx,4)	0xf000+0x0100*4	0xf400
0x80(%ecx,%edx,2)	0x80+0x0100+0xf000*2	0x1e180

 

Process Address space

stack : local 변수, 프로그램이 돌면서 사용하는 메모리 공간

heap : malloc, ...

 

 

EX) Swap Example

void swap(int *xp, int *yp) { 
int t0 = *xp;
int t1 = *yp;
*xp = t1;
*yp = t0;
}

main() {

int x,y;

swap(&x,&y);

}

swap:
  // setup 부분
  pushl %ebp
  movl %esp, %ebp
  pushl %ebx
  
  // body 부분
  movl 12(%ebp), %ecx
  movl 8(%ebp), %edx
  movl (%ecx), %eax
  movl (%edx), %ebx
  movl %eax, (%edx)
  movl %ebx, (%ecx)
 
  // finish 부분
  movl -4(%ebp), %ebx
  movl %ebp, %esp
  popl %ebp
  ret

 

---

 

Arithmetic/Logical Ops.

연산

Two operands instructions

• addl Src, Dest Dest = Dest + Src 

• subl Src, Dest Dest = Dest - Src 

• mull Src, Dest Dest = Dest * Src (unsigned) 

• imull Src, Dest Dest = Dest * Src (signed) 

• sall Src, Dest Dest = Dest << Src (= shll)                // shift arithmetic left

2를 곱하는 결과, 좌측으로 밀고 0넣음

• sarl Src, Dest Dest = Dest >> Src (Arith.)                 // shift arithmetic right

2를 나누는 결과, 우측으로 밀고 MSB 유지

C언어 >> 는 sarl

• shrl Src, Dest Dest = Dest >> Src (Logical)               // shift right l

논리시프트는 MSB가 보존되지 않는다(오른쪽이든 왼쪽이든 무조건 0)

• xorl Src, Dest Dest = Dest ^ Src  

• andl Src, Dest Dest = Dest & Src 

• orl Src, Dest Dest = Dest | Src

 

One operand instructions

• incl Dest Dest = Dest + 1
• decl Dest Dest = Dest - 1
• negl Dest Dest = -Dest 

• notl Dest Dest = ~Dest

 

 

Address Computation

leal Src, Dest

leal : load effective address long

Src : address mode expression

Set Dest to address denoted by expression ; 레지스터

 

movl	leal
movl (%edx, %edx, 2), %edx	leal (%edx, %edx, 2), %edx    // x = 3 * x;
Src의 계산결과 3x,  메모리에 가서 '3x' address에 있는 값을 edx에 넣는다
Src 메모리에 쫓아감	메모리 접근이 아닌 그냥 그대로 edx에 넣음

• Computing address without doing memory reference
- e.g., translation of p = &x[i];
• Computing arithmetic expressions of the form x + k*y
- k = 1, 2, 4, or 8

 

 

---

Ex. arith

int arith (int x, int y, int z) { 
int t1 = x + y;
int t2 = z + t1;
int t3 = x + 4;
int t4 = y * 48;
int t5 = t3 + t4;
int rval = t2 * t5;

return rval;
}

 

Ex. logical

int logical(int x, int y) { 
int t1 = x ^ y;
int t2 = t1 >> 17;
int mask = (1 << 13) - 7;  // 변수가 아니라서 (상수) 미리 계산, 2^13-7
// int mask = 8185;
int rval = t2 & mask;
return rval;
}

 

 

 

Ex. and or

int andor (int x, int y)
{
int t2 = x & y;
int t3 = 0xffffffff;
int rval = t3 | t2;
return rval;
}

 

CISC Properties

Complex Instruction Set Computer

RISC는 Reg만 받기, Mem 접근x

• Instruction can reference different operand types
- Immediate, register, memory
• Arithmetic operations can read/write memory 

mem를 operand로 받으면 cpu가 직접 값을 쓰거나 읽기를 하고, 그런 logic이 cpu에 설계되어있다

• Memory reference can involve complex computation
- D(Rb, Ri, S) -> Rb + S*Ri + D 

- Useful for arithmetic expressions, too

• Instructions can have varying lengths
- IA-32 instructions can range from 1 to 15 bytes

clock이 달라질수도

 

Machine level programming
• Assembly code is textual form of binary object code 

asm line하나하나가 그대로 기계어로 직역될 수 있다

• Low-level representation of program
- Explicit manipulation of registers 

cpu내부구조 알아야, 어떤 R에서 R로

- Simple and explicit instructions 

- Minimal concept of data types 

- Many C control constructs must be implemented with multiple instructions