BLOG main image
LoofBackER's Blog
Jun - Sik , Yang Blog

http://ideas.live.com/

분류없음 2007.03.30 15:58 by LoofBackER
http://ideas.live.com/
신고
크리에이티브 커먼즈 라이선스
Creative Commons License

스타크레프트 테란음악연주

분류없음 2007.03.25 01:29 by LoofBackER
신고
크리에이티브 커먼즈 라이선스
Creative Commons License

몇일을 고생한 그 인간한테 알아낸거..

일단 2005로 프로젝트를 연다음에

다음과 같이 한다.


Tools 에 Divide Emulator Manager 를 선택 하면



다음과 같은 화면이 나온다.

다음으로는

Connect를 선택하면 에뮬레이터가 연결이 된다.

그다음에


Cradle 을 선택 한다.

그러면 이렇게 ActiveSync 가 Connecting을 시도 한다.

그러다가 만약 Failed 가 되서 Not Connected가 되면


즉 이렇게 된다면

다시 한번 찾아보아야 한다.


그러면 알아서 찾는다 이렇게 like this~~

 


이제는 인터넷이 된다.

이렇게 ~~


신고
크리에이티브 커먼즈 라이선스
Creative Commons License

학생 포트폴리오 경진대회

분류없음 2007.03.21 05:29 by LoofBackER

<학생 포트폴리오 경진대회 >

■ 주최 : 한국공학교육인증원(ABEEK) 부설 한국공학교육연구센터

■ 개최목적

(1) 학생들에게  취업 등 향후 진로를 위한 인터뷰 시에 필요한 자신의 포트폴리오 작성의 기회를 제공하고,

     경력 개발의 필요성을 부각하여 보다 적극적인 자기 개발 및 홍보를 유도한다.

(2) 산업체에 우수한 학생을 유치할 수 있는 기회를 제공한다.


■ 참가자격


(1) 2007년 봄학기 현재 4년제 대학 공학계열대학 재학 중인 3, 4학년 대학생

(2) 1인당 한 개의 포트폴리오만 제출 가능


■ 참가방법


(1) 아래의 서류들을 한국공학교육연구센터에 우편으로 제출하여야 합니다.

(2) 제출기한: 4월 23일 (월) – 5월 4일 (금)

   ※ 2007년 4월 30일(월요일)자 소인까지 유효하며 반드시 2007년 5월 4일(금요일) 까지는 도착하여야 합니다.

(3) 제출처 : (135-080) 서울 강남구 역삼동 701-7 한국기술센터 17층 한국공학교육연구센터


■ 제출물


(1) 참가신청서

(2) 포트폴리오 요약본 (10장 이내)

(3) 이력서 (3장이하)

(4) 지도 교수 (또는 학과장) 확인서

(5) 서약서

(6) 포트폴리오 인쇄물 또는 e-포트폴리오(CD제출) (각 300페이지 분량 이내)

(7) (1), (4), (5)의 양식은 한국공학교육연구센터 홈페이지(http://www.koreaeerc.or.kr/)에서 다운로드해서

     사용



■ 포트폴리오 작성


(1) 포트폴리오는 회사 인터뷰 또는 대학원 진학 등의 목적에 맞게 자유로운 형태로 작성할 수 있습니다.

(2) 포트폴리오의 내용은 사본으로 작성 가능하며, 제출된 서류는 원칙적으로 반환되지 않고 심사 후

    보안상 폐기처분 됩니다(단, 반송용 봉투 첨부 시 반송함)

(3) 포트폴리오의 내용에는 아래의 내용이 반드시 포함되어야 합니다.

   (a) 프로필:자신의 포트폴리오를 소개하기 위한 내용 (예: 이력서, 자격증, 경력 등)

   (b) 기술부문:  학생 본인이 수행한 프로젝트 예제, 인턴쉽 등 특정기술내용

(4) 또한 위의 내용 이외에도 원하는 진로, 회사, 대학원 인터뷰를 위해 필요한 내용이 포함될 수 있습니다.

 

■ 제출분야


분류 학문분야
1분야 기계 항공우주 조선해양 산업
2분야 토목 건축 환경 자원
3분야 전기 전자 컴퓨터 기타
4분야 화공 생명 재료 섬유


   ※ 심사는 한국공학교육인증원 기준에 따라 분야별(4개 분야)로 진행한다.


■ 포상


대상 : 총 1편(상장 및 부상 수여)

금상 : 분야별 1편 총  4편(상장 및 부상 수여)

은상 : 분야별 2편 총  8편(상장 및 부상 수여)

동상 : 분야별 3편 총 12편(상장 및 부상 수여)

장려상:  분야별 10편 총 40편(상장 및 부상 수여)

■ 일정


5월 4일 (금): 접수마감

5월 18일 (금): 심사

5월 28일 (월): 포상

신고
크리에이티브 커먼즈 라이선스
Creative Commons License

ASM Flash

분류없음 2007.03.16 13:46 by LoofBackER


http://namhae.duksung.ac.kr/~miok/system_pro/source.htm
masm down

신고
크리에이티브 커먼즈 라이선스
Creative Commons License
TAG ASM

Win32 MASM 프로그래밍 소개(Visual C++이용)

Written by 권필진. 06'08 - aka Xeno


Chapter 1   준비사항

개요 : Win32 프로그래밍을 시작하기 전에

Chapter 1 - 1   주의 사항

MASM 프로그래밍을 하기 전에, 모든 책임은 자신이 진다는 것을 명심하기 바란다. MASM은 로우레벨의 명령어를 실행할 수 있기 때문에, 버그가 발생했을 경우 컴퓨터에 치명적인 에러 혹은 PC자체가 작동하지 않는일도 있을 수도 있다. 그러므로,

이 문서로 인하여 발생한 손해 및 문제는 필자가 어떠한 책임과 보상도 지지 않음을 숙지하고 읽어나가기 바란다.

(너무 겁먹을필요는 없다)

주의:이 문서는 2006년경에 작성 했다. 테스트 환경으로서는 WindowsXP-SP2환경으로 테스트했다. 본 문서는 수시로 변경 될 수도 있다.

Chapter 1 - 2   MASM 입수

MASM 이란, 마이크로소프트사의 어셈블러 툴이다. 현재는 무상으로 제공되기 때문에, 어셈블러공부를 하고 싶다면 지금이 최적의 시기이다. 어셈블리를 익히게 된다면 컴퓨터에 대해 지금까지 몰랐던 것을 알 수있게 될지도 모른다. 하지만, MASM을 설명하는 곳은 드믈고 자료또한 거의 없기 때문에 이렇게 문서를 작성하고 있는 것이다. 또한, 본 문서는 간단한 소개정도에 그치는 수준이며 좀더 자세한 내용은 추후로 미루는 것 또한 알아두기 바란다.

그렇다면 먼저, MASM을 구해야 한다. 이미 말했듯이, 현재는 무상으로 제공되기 때문에, 마이크로소프트의 홈페이지에서 다운로드 한다. 마이크로소프트의 DDK (Driver Development Kit) 라는 패키지 안에 포함되어있다. DDK 는, 20메가 이상의 크기일것이므로 다운로드하는데 시간이 걸릴지도 모른다.

참고로, DDK 에 들어있는 MASM은 버젼이 낮고 MMX명령어를 인식하지 못하기 때문에, 강좌와 버젼을 맞출려면 「패치」를 해주어야 한다. 패치 또한 마이크로소프트의 홈페이지에서 구할 수가 있고, 다운로드한 후 압축을 해제하고 , 파일들을 모두 MASM이 있는 디렉토리안에 복사 한 후「패치」실행 파일을 실행한다.

MASM 의 버젼이 최신상태로 되었다면, VC++ 에서 MASM를 사용할 수 있도록 설정한다. 이렇게 하면 VC환경에서 어셈블리환경을 사용할 수가 있게 되므로, 여러가지 편리한 점이 있다.

가장 먼저 해야하는 것은, MASM 를 구해야 한다. 이것은 아래의 장소에서 구할 수가 있다.

상기에서 설명했듯이 MASM을 구하고 패치를 해야하지만 번거롭다. 이럴경우 VC용 패키지가 존재한다. 본 강좌에서는

이방법을 사용하기로 한다.

Visual C++ 6.0 에 MASM를 추가하는 가장 간단한 방법은, ProcessorPack 의 추가이다. 이미 ML버전이 6.15가 포함되어 있기 때문에, 패치 단계가 필요없다. 하지만, 패키지가 SP4 ,SP5 전용이기 때문에, SP6 을 설치했다면, /C 옵션을 사용해서 압축을 해제한 후 직접 설치해 주어야한다. 참고로 VisualStudio.NET 이상 버전에는 ML.EXE 는 추가해 주지않아도 이미 포함 되어있다. 2002 는 버전 7.00 이며, 2003에는 7.10 이 포함 되어 있다. 아래의 주소에서 ProcessorPack을 다운로드 할 수있다.

http://msdn.microsoft.com/vstudio/downloads/tools/ppack/default.aspx 에서 "Download Now" 부분을 클릭한다. 혹은 http://download.microsoft.com/download/vb60ent/update/6/w9x2kxp/en-us/vcpp5.exe 링크를 클릭해서 다운 받은 후 vcpp5.exe / c 옵션으로 압축을 해제해도 된다. WinZip과 같은 압축 프로그램으로도 압축을 해제할 수있다.

압축해제한 후 해당 폴더를 VC의 설치 폴더에 통째로 복사해준 후 아래의 순서대로 경로를 잡아주면 된다.

MASM를 구했는가? MASM의 프로그램 파일명은 ML.EXE 라는 이름이다. 이 프로그램은 소스파일을 어셈블링 해주고 링크까지 해주게 되며,원한다면, 오브젝트파일만 생성해 줄 수도 있다.(16bit링커사용시)

추가로, 본강좌에 사용되는 Microsof Visual C++ 6.0은 제공해 줄 수가 없다. 각자 구하기 바란다.(-_-)

사용된 소스는 복사해서 붙여넣기를 수행해도 작동하도록 되어있으며, 텍스트뷰어는 소스파일의 링크를 클릭해서

해당 .dsw파일을 열어서 F5키를 눌러서 실행하면 된다.



Chapter 1 - 3   VC++에서 MASM을 사용하도록 설정

이제부터는, MASM를 VC++에서 사용할 수 있도록 해보자. MASM을 VC++ 에서 사용할려면, VC++의 「커스텀 빌드」라는 기능을 사용해야한다.

먼저 File -> New 를 선택해서 Win32 Application을 선택한 후 "An Empty Project"를 선택한 후 다시 File->New를

선택해서 Text File을 선택하고 파일명을 "VCMASM.ASM"이라고 정해주고 아래의 내용을 수행해 보기 바란다.

VC++에서 ML.EXE 를 실행해야 하므로, 실행파일 경로를 설정해주어야 한다. 「Tools」-> 「Options」을 선택하고 아래와 같이 설정한다.

Directories」탭으로 이동후에 반드시 「Executable Files」를 선택하기 바란다. 추가 버튼을 눌러서 압축해제한 폴더를 지정해준다. 참고로, 가장 하단에 추가하기 바란다. 본 강좌에서는 C:\VC60\VCPP5 라는 폴더이다.

이제 실제로 간단한 프로그램을 만들어 보자.

File -> New로, Win32 application 의 시작 프로젝트를 작성한다. 그런 다음에, MASM의 소스코드를 작성합니다. 이것은 File -> New -> Files탭에서, 확장자(extension)가 ASM 이 되게끔 하고 신규파일을 작성한다.

그런 다음, 커스텀 빌드의 설정을 한다. Project -> Setting을 선택하고, 어셈블리 소스 파일을 선택한다. 커스텀 빌드 탭을 선택한 후, 아래와 같이 설정한다.

Commands 텍스트 박스에는,

ml /c /coff /Cx /nologo /Fo$(OutDir)\ /Fl$(InputName) /Zi $(InputPath)

로 설정한다. 이는 디버그 모드의 경우지만, 릴리즈 모드로 할 경우, 커맨드에 있는 /Zi 플래그를 제거하면 된다.

Outputs의 텍스트박스에는,

$(OutDir)\$(InputName).obj

로 설정해 준다. 이제부터는 VC에서, Build-> Run 을 선택하면, 자동으로 어셈블해주고 링크도 VC++가 알아서 해주게 된다. 하지만, 조금 번거로운것은, 파일을 작성할 때 마다 커스텀 빌드를 설정해 줘야 한다는 것이다.

좀 더 자세한 자료는 다음부분을 참고하기 바란다 → Microsoft Support Q106399  (영어)

커스텀 빌드에 대해, 좀 더 자세하게 알고 싶다면, MSDN에 자료가 아주 상세하게 설명되어 있기 때문에, 그부분을 참조하기 바란다.

Chapter 1 - 4   최초의 MASM 프로그램

모든언어의 표준 입문 방식인 「Hello World」프로그램을, MASM으로 간단하게 만들어 보자. 물론 무슨 내용인지 몰라도 상관없다. 모르는것이 당연한 것이며, 그래서 본 문서가 있는것이다.

;**********************************************************************
; 최초 MASM 프로그래밍
; 주석은 세미콜론으로
;**********************************************************************

.586
.model flat, stdcall

NULL            EQU     0

MessageBoxA     proto :dword, :dword, :dword, :dword
ExitProcess     proto :dword

.data

TITLE1          DB '어셈블리 테스트', 0
MESSAGE         DB '~Hello World!!~', 0

.code
WinMainCRTStartup   proc

    invoke MessageBoxA, NULL, offset MESSAGE, offset TITLE1, 0
    invoke ExitProcess, 0
    ret
WinMainCRTStartup   endp
end

이 내용을 어셈블(assemble) 한 후 실행하면(F5), "~Hello World!!~"라고 표시되는 메시지 박스가 화면에 표시된다.

(안된다면 십중 팔구 오타이니 복사해서 붙여넣기 바란다)

(주의) 위의 소스에는 편의상 색을 다르게 표시했지만, 실제로는 변하지 않는다. (전용 통합환경을 사용하면 모든기능을 사용할 수가 있다. 많은것을 바라지는 말기 바란다. WinASM IDE를 사용하라.)


Chapter 2   하드웨어의 구조

개요 : 컴퓨터에 대해서

Chapter 2 - 1   하드웨어

이번에는, 간단하게 하드웨어의 구조에 대해 설명한다. 하드웨어의 구조라 하더라도, USB의 규격이나, 메인보드는 어떻게 구성되어 있는가, 그런 것을 다루는 것이 아니다. 대부분을 CPU 의 구조에 대해 설명을 할 것이다. 「최소한, 이것만은 반드시 알아야 한다」라는 부분을 위주로 해서 설명해 나갈것이다.

다음의 순서로 설명 할 것이다.

  1. 어셈블러에서 가능한 것
  2. 저장장치(레지스터/메모리/스택)
  3. 외부 입력과 외부 출력(I/O)·인터럽트
  4. BIOS·시스템 콜·VRAM

Chapter 2 - 2   어셈블러에서 가능한 것

먼저, 왜 어셈블러를 사용 할까? 그 이유는, 몇가지가 있다. 대부분의 프로그래밍은, C언어로도 충분하다. 일반적으로 말해, 언어가 고급으로 될수록 , 인터프리터성이 높아져서 , 언어가 사람이 이해하기 쉬워지지만, 그 언어로 실제 수행되는 부분은 오히려 감소하게 된다. 즉, Basic과 C언어의 예를 들면, Basic에서 할수 있는 일은 C언어로도 수행 할 수 있다.하지만 반대로, C언어로 수행할 수 있는 것이 반드시 Basic 에서 수행된다는 보장은 없다. 같은 맥락으로 C언어와 어셈블러의 관계에서도 존재한다. 예를 들어 C언어에서는, 하드웨어를 직접조작은 할 수 없다(물론 인라인어셈블리를 사용할 수는 있지만). 단지 예를 든것이다. 그렇기 때문에, 직접 하드웨어를 조작하고 싶은 경우 등에 어셈블러를 사용한다. 직접 하드 디스크의 트랙이나 섹터를 조작하고 싶은 경우에 어셈블러를 사용한다라고 생각하면 이해하기 쉬울 것이다.

프로그램이 고속성을 요구하는 경우, C언어보다 어셈블러 쪽이 일반적으로 빠르기 때문에, 이런 경우는 어셈블러에서 프로그램을 주로 짠다. 그렇지만, 어셈블러는 너무 로우레벨이므로, 프로그래밍에는 상당한 노력을 필요로 하고 코딩의 양도 많아진다. 그러므로, 어셈블러에서만 프로그래밍을 하는 것은, 현실적이지는 않다. 많은 경우, C언어등의 고급(중급) 언어와 함께 조합해서 사용하게 된다.

Chapter 2 - 3   저장장치(레지스터/메모리/스택)

기억장치에는, 3 종류가 있다. 레지스터와 메모리와 스택이다. 이 밖에도, 보조기억장치로 하드 디스크나 플로피 디스크등이 있다. 어셈블러에서는, 주로 레지스터와 스택을 이용한다.

레지스터는, CPU의 내부에 있는 기억장치이다. CPU의 내부에 존재하므로, 액세스 속도 또한 아주 빠르다. 그렇지만, 레지스터는, 무한정으로 사용할 수 있는 자원이 아니다. 레지스터의 종류에는, 3개 있다. 범용 레지스터,세그먼트 레지스터,플래그 레지스터.

레지스터 종류 해설
범용 레지스터
8개가 있다. 프로그램에서 사용된다.
세그먼트 레지스터
6개가 있다. 세그먼트(segment)의 관리에 사용된다.
상태 레지스터
1개가 있다. CPU 상태를 기억한다. 일반적으로 변경할 수 없다.

프로그래밍에서는, 거의 대부분 범용 레지스터를 사용한다. 범용 레지스터에는, 다음의 8가지가 있다. 모두 32 비트이다.

레지스터명 해설
EAX
어큐물레이터. 수치계산에 사용되는 레지스터.
EBX
베이스 레지스터. 보조 계산이나, 그 외의 용도에 사용되는 레지스터.
ECX
카운터 레지스터. 보조 계산이나, 카운터, 루프에서 사용되는 레지스터.
EDX
데이터 레지스터. 보조 계산이나, 데이터용 조작용의 레지스터.
ESI
소스 인덱스. 보조 계산이나, 데이터 처리 인스트럭션으로 사용되는 레지스터.
EDI
목적지 인덱스. 보조 계산이나, 데이터 처리 인스트럭션으로 사용되는 레지스터.
ESP
스택 포인터. 스택 처리로 사용되는 레지스터.
EBP
베이스 포인터. 스택 처리로 사용되는 레지스터.

C언어에서 변수의 수식자에 register 를 지정할 수 있다.(레지스터변수) 이런 경우 실제로는, 변수에 ESI(소스 인덱스)와 EDI(목적지 인덱스)를 사용하게 된다.또한, 계산용의 레지스터로서 ESP(스택 포인터)와 EBP (베이스 포인터) 를 사용할 수 없다. 이런 레지스터 들은, 스택관리라고 하는 중요한 임무가 있기 때문 이다. 수치계산은, 실질적으로 6개의 레지스터로 하게 된다. 각각의 레지스터에는, 고유한 역할도 있으므로, 거기에 맞춰서 프로그램을 짜지 않으면 안된다. 왜 이런 엄격한 룰이 존재하는지를 탓하지 말기 바란다. 컴퓨터는 복잡한 장치이다. 하지만 이런 기초적인 룰만 익히면 어떤언어보다 강력함을 얻을수 있다. 대충 아는 언어와는 다른 것이다.


32 비트의 경우, 누산기는 EAX 로 취급하지만 하위 16 비트를 AX 로서 다룰 수도 있다. AX 는 또 다시, 상위 8 비트를 AH , 하위 8 비트를 AL 로 나타낸다. 이것은, EBX ECX EDX 의 경우도 같다.

그렇다면, 이제 레지스터를 사용한 프로그램을 살펴보자.

;*****************************************************************
;  레지스터를 사용한 프로그램
;*****************************************************************

.586                   ; Pentium 용의 코드를 쓰는 경우 필요
.model flat, stdcall

NUM         EQU   1

wsprintfA   proto c :dword, :dword, :dword, :dword, :dword
MessageBoxA proto   :dword, :dword, :dword, :dword
ExitProcess proto   :dword

.data

BUFFER      DB 64 DUP(0)
STRINGS     DB '%d + %d = %d', 0
TITLENAME   DB '결과는? ', 0

.code

WinMainCRTStartup proc

    mov eax, NUM     ; 누산기에 대입
    mov ebx, NUM + 1 ; 베이스 레지스터에 대입
    add eax, ebx     ; 누산기와 베이스 레지스터를 더한다

    invoke wsprintfA, offset BUFFER, offset STRINGS, NUM, ebx, eax
    invoke MessageBoxA, 0, offset BUFFER, offset TITLENAME, 0
    invoke ExitProcess, 0

    ret
WinMainCRTStartup endp

end

덧셈을 한 후, 메시지 박스로 표시하는 프로그램이다("1+2=3"). 레지스터는, EAX(누산기)와 EBX(베이스 레지스터)를 사용하고 있다. 프로그램에서 mov 나 add 등을 니모닉이라 한다. 니모닉은, 기계어의 비트 표현을 문자표현으로 나타낸 것이다. 예를 들어 mov 라면, MOVe 의 약자로 「대입」을 의미한다. add (은)는 ADD 로 「가산」을 의미한다. 프로그램에서는 누산기와 베이스 레지스터에 수를 대입해서 ,덧셈을 수행하고 있다.

MASM에서, 함수를 프로시저라고 부른다. 프로시저의 정의는, proc - endp 로 한다. 위의 예에서는 , WinMainCRTStartup 라는 프로시저가 정의되어 있고, 그 사이의 기계어 인스트럭션이 실행되고 있다고 생각하면 된다.

이 함수는 스타트 업 코드(Startup Code)로 불리고 프로그램에서 가장 먼저 호출되는 함수다. 보통 C로 프로그램을 짜는 경우, 스타트 업 코드는 자동으로 생성되어 링크 된다. 또한 스타트 업 코드는, 프로그램을 초기화하는데 사용된다. VC++ 로 Windows 프로그래밍을 하는 경우, 스타트 업 코드는 WinMainCRTStartup 함수지만, Console 용의 프로그램의 경우는 mainCRTStartup 함수가 스타트 업 코드가 된다. 통합 환경에 의해, 스타트 업 코드 함수의 이름은 각각 다르다.반드시 정해진것은 아니다. 개발자 마음인것이다. main이란것을 찾지만 말기 바란다. 이것은 C언어의 룰일 뿐이다.실제로는 이런것은 없다.

Chapter 2 - 4   그 외 레지스터

상태 레지스터(flag register)는, 하나 밖에 없다. 레지스터의 내부는, CPU 상태를 보존하고 있다. 일반적으로 상태 레지스터 전체를 변경할 수 없다(스택을 사용하면 변경할 수 있지만, 권하는 방법은 아니다 pushf / popf). 플래그의 종류는,상태 플래그,제어 플래그,시스템 플래그의 3개가 있다. 상태 플래그는, 연산의 결과 상태가 보존된다. 상태 플래그의 종류는 다음과 같다.

플래그명 비트 해설
CF (Carry Flag) 0 carry flag. 자리수가 올라가면 세트.
PF (Parity Flag) 2 패리티플래그. 연산 결과가 짝수일 경우 세트.
AF (Adjust Flag) 4 조절 플래그. 2 진화 10진(BCD) 연산에서 사용.
ZF (Zero Flag) 6 제로 플래그. 연산 결과가 제로일 경우 세트.
SF (Sign Flag) 7 부호 플래그. 연산 결과가 부호가 있는 경우 세트.
OF (Overflow Flag) 11 오버플로우 플래그. 오버플로우가 발생하면 세트.

일반적으로 상태 플래그는 변경할 수 없지만, carry flag는 변경 가능하다. 니모닉 STC (SeT Carry flag), CLC (CLear Carry flag) 인스트럭션으로 변경할 수 있다.

제어 플래그는 DF (Direction Flag ; 방향 플래그) 밖에 없다. string 인스트럭션(메모리 전송 인스트럭션)에서, 메모리 전송 방향을 지정한다. 니모닉으로는, STD (SeT Direction flag) CLD (CLear Direction flag)를 사용한다.

시스템 플래그는, 가상 8086 인스트럭션이나 인터럽트 제어 등에 사용되지만 본 문서에서는 설명하지 않는다.인텔의 아키텍쳐 메뉴얼을 참조하기 바란다.

그러면, 상태 레지스터를 사용한 간단한 프로그램을 만들어 보자.

;*****************************************************************
;  상태 레지스터를 사용한 프로그램
;*****************************************************************

.586
.model flat, stdcall   ; 메모리모델은 플랫으로…

NUM         equ   1

wsprintfA   proto c :dword, :dword, :dword
MessageBoxA proto   :dword, :dword, :dword, :dword
ExitProcess proto   :dword

.data

BUFFER      db 64 DUP(0)
STRINGS     db '2의 10승은 %d 입니다', 0
TITLENAME   db '2의 10승을 푸는 문제', 0

.code

WinMainCRTStartup proc

    mov eax, NUM
    mov ecx, 10

MYLOOP:
    mov ebx, eax
    add eax, ebx
    dec ecx       ; ecx 의 값을 1 감소
    jnz MYLOOP    ; 제로 플래그가 세트 되지않으면 루프

    invoke wsprintfA, offset BUFFER, offset STRINGS, eax
    invoke MessageBoxA, 0, offset BUFFER, offset TITLENAME, 0
    invoke ExitProcess, 0

    ret
WinMainCRTStartup endp

end

먼저 WinMainCRTStartup 함수의 내용보자. 이번에는 2의 10승을 구하는 문제이다("2의 10승은 1024입니다"). ECX 레지스터의 내용을 1씩 감소해 가면서, ECX 레지스터가 0이 되면 종료하는 루프를 만들었다. dec (DECrement)라는 니모닉은, 레지스터의 내용을 1 감소시키는 인스트럭션이다(C에서 abc--). jnz (Jump if Non-Zero flag)란, 제로 플래그가 세트되지 않는 동안, 지정된 주소에 점프 하는 조건 점프 인스트럭션이다. 여기에서는 MYLOOP 라고 하는 주소로 점프 한다. MYLOOP 와 같이, 이름의 뒤에 구두점을(콜론) 붙여서 주소에 이름을 지정할 수가 있다.(레이블)

이번 예제에서는 상태 플래그의 사용법을 보기 위해서, 귀찮은 방법으로 프로그래밍했지만, 루프를 할 경우는 좀 더 편리한 니모닉이 준비되어 있다바로 loop (LOOP if ecx is non-zero) 라는 것이 있다. 위의 내용을 다시 작성하면 아래와 같이 된다.

mov ecx, 10    ; 루프 시키고 싶은 횟수만 ECX 에 대입

MYLOOP:
    mov ebx, eax
    mov eax, ebx
    loop MYLOOP    ; ECX 를 1줄여 0이 될 때까지 반복한다

또한 실제로 , 2의 계승을 구하는 좀 더 간단한 방법도 있다. 쉬프트를 사용하는 방법이다.

세그먼트(segment) 레지스터의 종류에는 다음과 같은 종류가 있다. 모두 16 비트이다.

레지스터 해설
CS 코드 세그먼트 실행 코드가 존재하는 세그먼트
DS ES FS GS 데이터 세그먼트 데이터가 존하는 세그먼트
SS 스택 세그먼트 스택이 존재하는 세그먼트

16 비트 시절에는 DS와 ES가 있었지만, 현재에는 FS DS 가 더해져서, 모두 「데이터 세그먼트」라고 불려진다.

세그먼트(segment)란, 연속된 메모리를 필요에 따라서 분할하고, 그 하나하나를 가리키는 의미이다. 예를 들어, 1개의 프로그램에는, 실행 코드와 데이터가 있다. 이것을 분할한 영역에 두는것이 바로, 세그먼트(segment)의 발상이다. 예를 들면, 실행 코드는 CS 세그먼트(segment)에 놓여지고, 데이터는 DS 세그먼트(segment)에 놓여지게 된다. 세그먼트(segment)는 같은 연속적인 메모리에 할당할 수 있고, 세그먼트(segment)끼리 서로 겹쳐 지는 경우도 있다.

예제 프로그램을 보면 .code 라고 하는 code segment를 정의하고 있다. 또한 .data 라는 데이터 세그먼트를 정의하고 있다. 그 밖에도 .stack 등도 있어서, 스택 세그먼트도 정의할 수가 있다. 하나의 세그먼트(segment)에는, 4 G바이트까지(!) 사용할 수 있다(2의 32승 : 그래서 32비트). 예를 들어 CS 세그먼트(segment)라면 CS:00000000h ~ CS:FFFFFFFFh 까지의 영역이 존재한다. 물론, 실제 메모리는 이렇게 사용되지는 않는다. 단지 예를 든 것이다.


Chapter 2 - 5   메모리

기억장치이다.「메모리」에 값을 대입할 수도 있다. 우선, 프로그램을 보자.

;*****************************************************************
;  메모리를 사용하는 프로그램
;*****************************************************************

.586
.model flat, stdcall  
; stdcall 은 함수의 호출 방법을 정의!

NUM         equ   32

MessageBoxA proto   :dword, :dword, :dword, :dword
ExitProcess proto   :dword

.data

BUFFER      db 128 dup(? )
TITLENAME   db '메모리에 대입하는 프로그램', 0

.code

WinMainCRTStartup proc

    mov    ecx, NUM            ; 카운터의 회수
    mov    edx, offset BUFFER  ; 버퍼의 포인터
    mov    ah, 20h
    ;

 _LOOP0:
    mov    byte ptr [edx], ah
    inc    ah
    inc    edx
    loop   _LOOP0

    invoke MessageBoxA, 0, offset BUFFER, offset TITLENAME, 0
    invoke ExitProcess, 0

    ret

WinMainCRTStartup endp

end

이번 프로그램은, 128바이트의 정적 버퍼를 확보하고, 그 영역에 문자를 차례차례 대입하는 프로그램이다. 실제로 「 ! "#$%&'()*+,-. /0123456789:<=>?」라는 문자가 대입된다. ASCII 코드의 20h 부터 3Fh 까지이다. 메모리에 대입하는 경우에는 ptr 연산자를 사용한다. [edx]란 edx 가 가리키는 메모리를 나타냅니다. byte ptr [edx] 란, 「edx 가 가리키는 메모리에 바이트값(8 비트)으로 값을 대입하라」라는 의미이다. 워드값으로 값을 대입하는 경우에는, word ptr [edx] 가 된다. C에서 어렵다고 하는 "포인터"이다. 어셈블리에서는 기본이 포인터이므로, 복잡하지 않다. 필자의 경우도

처음에 C를 할때 괜히 헷갈렸다. 오히려.......

Chapter 2 - 6   스택

스택은, 후입선출 (Last-In First-Out) 형태의 데이터 구조이다. 어셈블러에서 스택은 중요한 역할을 한다. 레지스터의 내용을 일시적으로 저장하거나 프로시저 호출 시에 인수를 스택에 넣거나 한다. 특히 C언어나 Pascal 등은, 함수 호출시 인수를 스택에 넣어 호출을 수행한다.이것을 함수호출 규약이라고 부른다.

그렇다면, 스택을 이용한 프로그램을 보자.

;*****************************************************************
;  스택을 사용한 프로그램
;*****************************************************************

.586
.model flat, stdcall

NUM         equ   5

wsprintfA   proto c :dword, :dword, :dword
MessageBoxA proto   :dword, :dword, :dword, :dword
ExitProcess proto   :dword

.data

BUFFER      db 64 dup(0)
TITLENAME   db '스택을 사용하는 프로그램', 0
STR1        db '카운트다운 %d', 0

.code

WinMainCRTStartup proc

    mov     ecx, NUM

 _LOOP0:
    push    ecx       ; SubFunc 로 ECX 를 스택에 보존
    call    SubFunc
    pop     ecx
    loop    _LOOP0

    invoke ExitProcess, 0

    ret

WinMainCRTStartup endp

SubFunc proc          ; 새로운 프로시저를 정의

    invoke wsprintfA, offset BUFFER, offset STR1, ecx
    invoke MessageBoxA, 0, offset BUFFER, offset TITLENAME, 0

    mov     ecx, 99   ; 여기서 ECX 의 값을 바꿔도, 스택에 값이 보존되있기 때문에 문제없다

    ret

SubFunc endp

end

이번에는, SubFunc 라는 새로운 프로시저(함수)를 만들어 보았다. 간단한 프로그램이므로, 특별히 문제는 없을 것이다. ("카운트다운 5")라는 결과가 나온다.이후 "카운트다운 4" "3"등으로 1까지 감소한다. push 니모닉은 레지스터의 내용을 스택에 대입한다. pop 은 스택으로부터 값을 레지스터에 대입한다.스택을 사용하는 MOVe라고 생각하면 쉽다. call 은 프로시저를 호출한다. 이 때, 현재 실행중인 주소를 스택에 대입하고 나서 프로시저로 점프 한다. 프로시저에서 돌아오는 경우에, ret 을 사용한다. ret 은 스택으로부터 값을 꺼내고, 호출시 원래의 주소로 돌아오게 된다.

Chapter 2 - 7   I/0·인터럽트

CPU 로 계산만 수행해서는, 컴퓨터의 진정한 능력을 사용 할 수가 없다. 컴퓨터의 기능을 활용하기 위해서는, 주변장치의 입력이나 출력을 제어할 수 있어야 한다. 예를 들어, 키보드로부터 입력을 받는다거나 디스플레이 장치에에 결과를 표시하거나. 이런것을 제어하기 위해서 I/O 공간을 사용한다. I/O 공간은 16 비트의 공간에서 16 진수로 말하면 0000h - FFFFh 의 공간이다 (16 진수는 수치뒤에[h] 를 붙인다). 이 공간으로 데이터를 전송 하거나(외부 출력), 데이터를 받거나(외부 입력) 하는 방식으로 , 주변장치를 액세스 할 수가 있다.

윈도우즈에는, 「시스템 정보」를 표시하는 프로그램이 있다. 「시작 메뉴」의 「보조프로그램」안의 「시스템정보」 이다.이 프로그램으로, 어떻게 I/O 공간이 할당되어 있는지를 볼 수가 있다.

인터럽트는 하드웨어 인터럽트와 소프트웨어 인터럽트의 2 종류가 있습니다. 하드웨어 인터럽트란, 외부로부터 입력이 있었을 경우, 현재의 프로그램을 일시중지 하고, 별도의 프로그램을 실행하는 기능입니다. 예를 들어, 프로그램 A를 실행중에 키보드가 눌렸다고 가정 합시다. 이 경우 키보드가 눌려진 키를 버퍼에 보존해 두어야만 합니다. 거기서 하드웨어 인터럽트가 발생해 키보드버퍼에 값이 저장됩니다. 물론 하드웨어 인터럽트가 발생하면 , 플래그와 레지스터의 값은 스택에 저장되므로, 원래의 프로그램에는 아무런 영향도 끼치지 않습니다.

하드웨어 인터럽트의 예

소프트웨어 인터럽트의 예

이와는 달리, 소프트웨어 인터럽트는 프로그램에서 명시적으로 MS-DOS의 함수 호출이나, BIOS의 프로시저를 호출하는 것을 말합니다.(즉, 프로그래머가 발생시키는 인터럽트를 의미합니다)

프로그램의 예를 보고 이해하시기 바랍니다.

;******************************************************************************
; 소프트웨어 인터럽트를 사용한 프로그램
;   이 프로그램은 MS-DOS용의 프로그램입니다
;   VC에서는 실행할 수 없습니다. 참고용으로 제작한 것입니다.
;******************************************************************************

.model small, c   ; 모델에서 small문을 먼저 기록하게되면 세그먼트(segment)는 16 비트가 된다
.286

;******************************************************************************
; 프로세스의 종료 매크로
;******************************************************************************
end_process macro ret_value

            mov   al, ret_value
            mov   ah, 4ch
            int   21h

            endm
;******************************************************************************
; 캐릭터 라인의 표시 매크로
;******************************************************************************
display     macro string

            mov   dx, offset string
            mov   ah, 09h
            int   21h

            endm

;******************************************************************************
; 1 캐릭터 입력(에코 없음) 매크로
;   AL = 키보드로부터 입력된 캐릭터
;******************************************************************************
read_kbd    macro

            mov   ah, 08h
            int   21h

            endm

;******************************************************************************
; 데이터 정의
;******************************************************************************
.data

MSG         db '이 프로그램은 즉시 종료합니다', 0dh, 0ah, '$'

;******************************************************************************
; 실행 프로세스
;******************************************************************************
.code

START:
            mov   ax, _DATA
            mov   ds, ax

            display     MSG   ; 메세지를 표시

            read_kbd          ; 버튼 입력 대기

            end_process 0     ; 프로그램의 종료


end START ; end 의사 인스트럭션의 뒤에는 스타트 지점을 기술

주석에서도 밝혔듯이, VC에서는 실행할 수 없습니다. VC의 링커는 32 비트이므로, 이 프로그램은 16 비트의 링커로 링크 하지 않으면 안됩니다. 16 비트의 링커는 아래에서 다운로드 받아서 사용하기 바랍니다.

ftp://ftp.microsoft.com/softlib/mslfiles/lnk563.exe

압축해제하면 16 비트의 링커가 생성됩니다. 32 비트용의 링커가 아니므로 주의하기 바랍니다.

이번 예에서는 매크로 정의하고 있습니다. 매크로는 함수와 달리, 호출된 곳에 치환됩니다. "복사" "붙여넣기"와 유사합니다. 호출이 아니고 대신 코드문이 바로 나타나게 됩니다. 이기능으로 매크로 어셈블리라고 불리게 됩니다. C++의 인 라인 함수와 같은 것입니다. 매크로는 보면 알 수 있듯이 macro - endm 로 정의되고 있습니다. 함수 호출에 대해서는, 16 비트 어셈블러 쪽을 참고 하시길 바랍니다.

Chapter 2 - 8   BIOS/시스템 콜 /VRAM

BIOS 는 메인보드에 장착되어 있는, 로우레벨로 하드웨어 조작을 하는 프로그램입니다. BIOS 는 소프트웨어라고 불리지 않고 펌 웨어라고 불리어 집니다. 직접 하드 디스크의 섹터에 기록하거나 읽어들이거나 하는 처리나, 플로피 디스크의 조작등의 로우레벨 함수들로 구성되어 있습니다.즉, 실제로 컴퓨터를 움직이는 가장 밑부분입니다.

시스템 콜이란, BIOS 나 OS 의 로우레벨 함수를 호출하는 것을 말합니다.

VRAM (Video RAM)에는, 캐릭터 VRAM 와 그래픽 VRAM 가 있습니다. 캐릭터 VRAM 란, 메모리상의 캐릭터를 디스플레이에 표시하는 RAM 입니다. 메모리상에 직접 캐릭터를 입력하는 것으로, 화면상에 캐릭터를 동기적으로 표시 할 수가 있습니다. 그래픽 VRAM 란, 메모리상의 데이터를 그래픽으로서 표시하는 RAM 입니다. 메모리와 화면의 그래픽은 서로 대응하고 있으므로, 메모리에 기록하는 것으로, 직접그림이나 곡선같은 객체등을 화면에 표시할 수가 있습니다. 그래픽 보드등에 있는 램에 해당합니다.

대부분의 경우 그래픽 VRAM 는, A000 : 0000 에 할당되어 있습니다.

우선 하드웨어의 구조는 이것이 다 입니다. 너무 간단하다고 생각 하실 것입니다. 윈도우 프로그래밍을 하게 될려면 먼저 도스나 시스템 프로그램에 대해서 알아야 합니다. 모든것에는 단계가 있습니다. 본 강좌는 상세 매뉴얼이 아닙니다. 이전에 한번쯤은 익혀보셨던 내용을 다시금 간단히 정리한 것입니다. 하지만 프로그래밍은 많은것을 요구하지는 않습니다. 간단한 명령어로도 훌륭한 프로그램을 작성 할 수 있습니다. 알고리즘을 언어의 문법에 맞게끔 작성하는 도구일 뿐입니다.이것을 이해하지 못하게되면 각종 언어를 섭렵해도 멀 했는지 모르게되는 딜레마에 빠지게 됩니다. 예를 들어서 영어의 문법만 잔뜩외우게 된후 실제 대화는 못하게 되는것이랑 같습니다. 미국의 꼬마는 문법을 배우지 않습니다. 말부터 배우고 자연히 문법을 익혀서 오류를 줄이고 멋지게 표현하는 법을 배우는것과 같은 이치입니다. 언어는 도구입니다.라는 말을 각종 개발자사이트에서 하는 이유는 이것입니다. 모든것을 외우려 하지 마시길 바랍니다. 기본적인것을 배우시고 활용을 하다가보면 막히는 부분도 발생하고 그런부분을 하나하나 익혀가시게 되면서 익히는 겁니다. 에 에 에 문법과 알고리즘을 보강하시게되고, 나중에는 자신만의 라이브러리와 개발방식을 타인에게 전파시킬 수 있는 것입니다.

그래도 먼가 찜찜하다고 생각하시는 분들은 어셈블리 기초강좌를 참조하시기 바랍니다. 이역시 강좌를 할 것입니다.

다음부터는 Windows 프로그래밍을 하게 됩니다. 기초지식으로서는, Windows API 에 대한 지식이 필요합니다만, 너무 자세히 알려하시기 전에 가볍게 체험 하신후에 별도의 서적등으로 공부하시기 바랍니다. MSDN도 훌륭합니다. 여기서는 자세하게 설명하지는 않습니다.


Chapter 3   Windows 프로그래밍

개요 : Windows 프로그래밍

Chapter 3 - 1   Windows 프로그래밍

MASM으로 Windows 프로그래밍을 시작해보자!

기초지식으로 Windows API, C 언어,CPU 등의 기본지식이 필요하다. 이런 부분에 대해서는 본 문서에서 자세히 설명하지 않으므로, 공부하기 바란다.


Chapter 3 - 2  최초의 프로그램

MASM으로 Windows 프로그래밍을 하는 것이지만, 처음으로 작성하는 것이라서 주석을 달아 두겠다.

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; 어셈블러 윈도우프로그래밍
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

.486
.model flat, stdcall

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; 정의
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
NULL      =       0
MB_OK     =       0

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; prototype
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
MessageBoxA proto :dword, :dword, :dword, :dword
ExitProcess proto :dword

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; 데이터 세그먼트
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.data

MSG1      db	'메세지 테스트',0
TITLE1    db	'타이틀',  0

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; code segment
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.code

WinMainCRTStartup	proc
    invoke MessageBoxA, NULL, offset MSG1, offset TITLE1, MB_OK
    invoke ExitProcess, 0
    ret
WinMainCRTStartup	endp

end

하나씩 설명하겠다. 먼저 .486 지시어이다. MASM에서, 486용의 인스트럭션을 생성하는 지시어이다. 예를 들어, .386으로 하게되면, 80386용의 인스트럭션을 생성하게 된다. .386p와 같이, CPU명 뒤에 p를 붙이게되면 특권 인스트럭션도 사용할 수 있게 된다. (p는 privilage→특권의 약자)

다음으로 .model 지시어이다. 이 인스트럭션은 메모리모델이라는 메모리사용 규약을 정한다. Win32 프로그램의 경우에는 플랫메모리모델만 사용하기 대문에, 메모리모델에는항상 flat를 지정한다. 또한, 함수(프로시저)의 호출 규약에는, Windows 프로그램 라이브러리의 호출 규약인 stdcall을 지정한다.

프로그램에서, WinMainCRTStartup라는 프로시저를 정의하고 있다. 프로시저를 정의하려면 , proc 지시어를 사용한다. 또, 프로시저 호출방법에는, 여러 가지가 있지만, 간략화된 호출 방법으로 invoke 지시어를 사용할 수가 있다. Invoke만 호출해줌으로써, MASM에서 프로시저 호출을 간단하게 수행할 수가 있게 된다. 복잡한 스택처리르 해주게된다. 이명령어와 다른 몇가지로 인해서 고급언어와 비슷하게 프로그램을 하게 될 수 있게 된다.

Windows 프로그램의 종료에는, 반드시 ExitProcess를 호출해야 한다. VC++에서는, 내부적으로 ExitProcess 를 호출한다. 왜 반드시 호출해야하는가 하면 , ExitProcess를 호출하지 않으면 완전하게 프로세스가 종료하지 않기 때문이다. 만약 호출하지 않는 경우는, 메모리상에 쓰레기값이 남는 경우도 발생할 수도 있다.

Chapter 3 - 3   인스턴스 핸들

인스턴스 핸들이란, 각각의 모듈의 실체를 나타내는 핸들이다.선뜻 이해가 되지 않을것이다 . 좀 더 자세하게 설명을 하겠다.

Windows에는, 모든 오브젝트를 "핸들" 로 다루게 된다. 그렇기 때문에 Windows에서, 실행 파일이 메모리상에 로드 되면, 어떤 형태로든 이"인스턴스"를 관리하지 않으면 안 되는 것이다. Windows는, 어플리케이션이 자신의 인스턴스에 대해서 조작을 수행할 경우 "인스턴스 핸들"을 그 값으로 넘겨주게 된다.(조작용 번호라고 생각하기 바란다)

그런데, 왜 인스턴스 핸들이 필요한가 를 설명하면, 실행파일(혹은 모듈)에 속해있는 리소스를 얻을려고 하는 경우에는, 이 인스턴스 핸들을"키"로해서 Windows에 요청해야 하는 것이다. 인스턴스 핸들의 존재 의미는,어찌보면 당연한 것이다.

먼저, 프로그램을 살펴보자.

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; 어셈블러 윈도우 프로그래밍
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.586
.model flat, stdcall

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; 정의
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
NULL	=	0
MB_OK	=	0

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; prototype
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
MessageBoxA       proto   :dword, :dword, :dword, :dword
GetModuleHandleA  proto   :dword
wsprintfA         proto c :dword, :dword, :dword
ExitProcess       proto   :dword

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; 데이터 세그먼트
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.data

MSG1	db	'인스턴스 핸들: 0x%X', 0
TITLE1	db	'타이틀 ', 0

STR1	db	64 dup(0)
hModule	dd	?

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; code segment
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.code

WinMainCRTStartup	proc
    invoke GetModuleHandleA, NULL
    mov    hModule, eax

    invoke wsprintfA, offset STR1, offset MSG1, hModule
    invoke MessageBoxA, NULL, offset STR1, offset TITLE1, MB_OK
    invoke ExitProcess, 0

    ret
WinMainCRTStartup	endp

end

실행(F5)해보면 모듈핸들 번호를 메세지 박스로 표시해준다. 컴퓨터마다 다를수 있으나 보통 0x400000형식이다.모듈 핸들을 얻기위해서는 GetModuleHandle 함수를 사용한다. 함수명 뒤에 붙어 있는 A의 의미는 문자열이 Ascii 코드라는 의미이다. 함수명 뒤가 W일 경우는, 문자열이 UNICODE라는 의미이다. 참고삼아 기억해 두기 바란다.

(NT의 경우는 기본값으로 유니코드방식이다)

WindowsAPI에 대해서는, MSDN 라이브러리를 참조하기 바란다.

Chapter 3 - 4   로컬 변수

다음에는, 로컬 변수에 대해서 알아보자.

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; 어셈블러 윈도우 프로그래밍
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

.586
.model flat, stdcall
option casemap:none

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; 정의
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
NULL	=	0
MB_OK	=	0

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; prototype
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
MessageBoxA       proto   :dword, :dword, :dword, :dword
GetModuleHandleA  proto   :dword
wsprintfA         proto c :dword, :dword, :dword
ExitProcess       proto   :dword

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; 데이터 세그먼트
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.data

MSG1	db	'인스턴스 핸들: 0x%X', 0
TITLE1	db	'타이틀', 0

;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; code segment
;++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.code

WinMainCRTStartup	proc
    ;---------------------------
    ; 로컬 변수
    ;---------------------------
    local pBuf[64] :byte
    local hModule  :dword

    ;---------------------------
    ; 프로그램 본체
    ;---------------------------
    invoke GetModuleHandleA, NULL
    mov    hModule, eax

    invoke wsprintfA, addr pBuf, offset MSG1, hModule

    invoke MessageBoxA, NULL, addr pBuf, offset TITLE1, MB_OK
    invoke ExitProcess, 0

    ret
WinMainCRTStartup	endp

end

프로시저 내부에서 local 지시어를 사용함으로써, 로컬 변수를 사용할 수가 있다. 위를 예에서 알수 있듯이, 로컬 변수의 선언은,

local  name[] :size

와 같이 한다. 위의 예에서는 배열을 지정했다. " 인스턴스 핸들: 0x400000"라는 결과가 나오게 된다.

Chapter 3 - 5   윈도우 생성

이제부터는, 실제로 윈도우를 생성해 본다. 프로그램의 내용이 좀 길지만 천천히 살펴보자.

;******************************************************************************
; 어셈블러 윈도우 프로그래밍 windows.asm
;******************************************************************************

.586
.model flat, stdcall
option casemap:none

;******************************************************************************
; 정의
;******************************************************************************

NULL              =       0
WM_DESTROY        =       2h
IDI_APPLICATION   =       32512
IDC_ARROW         =       32512
WHITE_BRUSH       =       0
WS_OVERLAPPED     =       00000000h
WS_SYSMENU        =       00080000h
WS_CAPTION        =       00C00000h
WS_EX_APPWINDOW   =       00040000h
SW_SHOWNORMAL     =       1
CW_USEDEFAULT     =       80000000h

HANDLE  typedef     dword
LPSTR   typedef     dword

POINT        struct
    x               dword   ?
    y               dword   ?
POINT        ends

WNDCLASS     struct
    style           dword   ?
    lpfnWndProc     dword   ?
    cbClsExtra      dword   ?
    cbWndExtra      dword   ?
    hInstance       HANDLE  ?
    hIcon           HANDLE  ?
    hCursor         HANDLE  ?
    hbrBackground   HANDLE  ?
    lpszMenuName    LPSTR   ?
    lpszClassName   LPSTR   ?
WNDCLASS     ends

MSG          struct
    hWnd            HANDLE  ?
    message         dword   ?
    wParam          dword   ?
    lParam          dword   ?
    time            dword   ?
    point           POINT   <?, ? >
MSG          ends

;******************************************************************************
; 프로시저 정의
;******************************************************************************

CreateWindowExA     proto   dwExStyle   :dword,
                            pClassName  :LPSTR,
                            pWindowName :LPSTR,
                            dwStyle     :dword,
                            x           :dword,
                            y           :dword,
                            nWidth      :dword,
                            nHeight     :dword,
                            hWndParent  :HANDLE,
                            hMenu       :HANDLE,
                            hInstance   :HANDLE,
                            pParam      :dword
RegisterClassA      proto   pWndClass   :dword
GetStockObject      proto   nObject     :dword
LoadIconA           proto   hInstance   :HANDLE,
                            lpIconName  :LPSTR
LoadCursorA         proto   hInstance   :HANDLE,
                            lpCurName   :LPSTR
GetMessageA         proto   lpMsg       :dword,
                            hWnd        :HANDLE,
                            nMsgFilMin  :dword,
                            nMsgFilMax  :dword
TranslateMessage    proto   lpMsg       :dword
DispatchMessageA    proto   lpMsg       :dword
PostQuitMessage     proto   nExitCode   :dword
DefWindowProcA      proto   hWnd        :HANDLE,
                            Msg         :dword,
                            wParam      :dword,
                            lParam      :dword
GetModuleHandleA    proto   lpstr       :LPSTR
ShowWindow          proto   hWnd        :HANDLE,
                            nCmdShow    :dword
UpdateWindow        proto   hWnd        :HANDLE
ExitProcess         proto   nExitCode   :dword

;*****************사용자 정의***********************
InitInstance        proto   hInstance   :HANDLE
CreateMyWindow      proto   hInstance   :HANDLE

;******************************************************************************
; 데이터 세그먼트
;******************************************************************************
    .data

ClassName   db  'FirstWnd', 0
WindowName  db  'First Application', 0

;******************************************************************************
; code segment
;******************************************************************************
    .code

;******************************************************************************
; 메인 함수
;******************************************************************************
WinMainCRTStartup    proc
    ;*************************
    ; 로컬 변수
    ;*************************
    local    msg     :MSG
    local    hWnd    :HANDLE
    local    hInst   :HANDLE

    ;*************************
    ; 프로그램
    ;*************************
    invoke GetModuleHandleA, NULL
    mov     hInst, eax

    invoke InitInstance, hInst
    cmp     eax, NULL
    je      ExitProg

    invoke CreateMyWindow, hInst
    cmp     eax, NULL
    je      ExitProg
    mov     hWnd, eax

    invoke ShowWindow, hWnd, SW_SHOWNORMAL
    invoke UpdateWindow, hWnd

MSGLOOP:
    invoke GetMessageA, addr msg, NULL, 0, 0
    or      eax, eax
    je      ExitProg

    invoke TranslateMessage, addr msg
    invoke DispatchMessageA, addr msg
    jmp     MSGLOOP

ExitProg:
    invoke ExitProcess, msg.wParam

    ret
WinMainCRTStartup    endp

;******************************************************************************
; 윈도우 클래스의 등록
;******************************************************************************
InitInstance    proc    hInstance:HANDLE
    ;*************************
    ; 로컬 변수
    ;*************************
    local    wc    :WNDCLASS

    ;*************************
    ; 프로그램
    ;*************************

    mov     wc.style, 0
    mov     wc.lpfnWndProc, offset MainWndProc
    mov     wc.cbClsExtra, 0
    mov     wc.cbWndExtra, 0

    mov     eax, hInstance
    mov     wc.hInstance, eax
	
    invoke LoadIconA, NULL, IDI_APPLICATION
    mov     wc.hIcon, eax

    invoke LoadCursorA, NULL, IDC_ARROW
    mov     wc.hCursor, eax

    invoke GetStockObject, WHITE_BRUSH
    mov     wc.hbrBackground, eax

    mov     wc.lpszMenuName, NULL
    mov     wc.lpszClassName, offset ClassName

    invoke RegisterClassA, addr wc

    ret
InitInstance    endp

;******************************************************************************
; 윈도우의 작성
;******************************************************************************
CreateMyWindow    proc    hInstance:HANDLE
    ;*************************
    ; 프로그램
    ;*************************

    invoke CreateWindowExA, WS_EX_APPWINDOW, offset ClassName,
        offset WindowName, WS_SYSMENU or WS_CAPTION, CW_USEDEFAULT,
        CW_USEDEFAULT, 300, 400, NULL, NULL, hInstance, NULL

    ret
CreateMyWindow    endp

;******************************************************************************
; 윈도우 프로시저
;******************************************************************************
MainWndProc    proc    hWnd:HANDLE, Msg:dword, wParam:dword, lParam:dword

    .if Msg == WM_DESTROY
        invoke PostQuitMessage, 0
    .else
        invoke DefWindowProcA, hWnd, Msg, wParam, lParam
    .endif

    ret
MainWndProc    endp

end

VC에서 실행(F5)하게 되면 "Line to long"이라고 에러가 나올것이다. 강좌에서는 편의상 여러줄로 했지만,

CreateWindowExA proto dwExStyle :dword ~ 이부분을 모두 한줄에 빈칸을 줄여서 작성해줘야한다.

프로그램을 보면 알 수 있듯이, Windows 프로그래밍은 코딩량이 많은것을 알 수가 있다. MASM32에는, 필요한 함수나 구조체의 정의를 정리한 파일을 제공해 주고있다. 그것을 사용하는것이 여러모로 편리할 것이다.

위의 프로그램에서는, 편의상 데이터형으로 핸들(HANDLE)과 문자열(LPSTR)과 정수로 나누고 있다.

MASM로 Windows 프로그래밍을 해 본 솔직한 의견으로는 MASM으로 Windows 프로그래밍을 할 정도라면, C 로하는 편이 훨씬 편하다. C와 비교해서 MASM으로 작성했다고 해서 특별히 빨라지는것도 아니기 때문에, 필요한 부분만 MASM 로 작성하는것이 주된 목적일 것이다. 좀 더 심하게 말해서 C의 인라인 어셈블러를 사용하는 것이 압도적으로 좋다.-_-;



Chapter 4   리소스의 이용

개요 : 리소스를 사용하는 경우

Chapter 4 - 1   리소스의 사용법

이번에는 리소스에 대해 설명한다. C언어에서 Windows 리소스를 사용하는것과 별다른 차이점은 없다.

그런데, 리소스에는 2 종류가 있다. 내부 리소스/외부 리소스라는 것이다.(필자의 사견이다)

내부 리소스는, 실행 파일에 포함되어있는 리소스이다. 실행 파일에 포함해 두면, 리소스 로딩을 빠르게 할 수가있다. 다만, 리소스가 실행 파일에 포함되므로, 실행파일의 크기가 커지게 되는 현상이 생긴다. 특히 비트맵과같은 것은 사이즈가 크므로 조심하기 바란다.

외부 리소스는, 문자 그대로 실행 파일에 포함되지 않는 리소스를 의미한다. 그러므로 실행중에 다른 파일로부터 로드하거나 스스로 만들어주지 않으면 사용할 수가 없다. 그런 만큼, 로딩하는 시간이 소모되게 된다.하지만, 메모리의 효율성에서는 더 좋다.


Chapter 4 - 2   인클루드 파일

상기의 예에서와 같이, 함수를 하나하나식 정의해서 사용한다면 매우 번거롭게 된다. 그래서 MASM32에 포함되어있는 함수와 정수를 정의한 인클루드 파일을 사용하게 된다. 다음의 4개의 파일을 기억해 두면 편리하다.

  1. windows.inc 윈도우관련정수가 정의되어 있는 인클루드 파일
  2. kernel32.inc 커널함수(코어 함수)가 정의되어 있는 파일
  3. user32.inc 유저함수(유저 인터페이스 함수)가 정의되어 있는 파일
  4. gdi32.inc GDI 함수(그래픽 디바이스 인터페이스 함수)가 정의되어 있는 파일

Chapter 4 - 3   아이콘과 다이얼로그 박스를 사용한 예

실제로 프로그램을 보자. 이번 예에서 사용하는 리소스는 다이얼로그 박스와 아이콘이다.


;******************************************************************************
; 리소스 사용 프로그램 resource.asm
;******************************************************************************

.486
.model flat, stdcall
option casemap:none

include <windows.inc>
include <kernel32.inc>
include <user32.inc>
include <gdi32.inc>

include <resource.inc>  ;리소스를 사용하므로 반드시 선언

;******************************************************************************
; prototype
;******************************************************************************

DlgProc             proto   hWnd    :HWND, 
                            Msg     :UINT, 
                            wParam  :WPARAM, 
                            lParam  :LPARAM
WinMainCRTStartup   proto
OnCommand           proto   hWnd    :HWND,
                            wParam  :WPARAM

;******************************************************************************
;  데이터 / 변수
;******************************************************************************

.data
MSG1    db          "정상적으로 표시되었는가? ", 0
TITLE1  db          "리소스 테스트", 0
hInst   HINSTANCE   ?

;******************************************************************************
;  코드
;******************************************************************************

.code
;------------------------------------------------------------------------------
;  다이얼로그 프로시저
;------------------------------------------------------------------------------
DlgProc proc \
    hWnd    : HWND,
    Msg     : UINT,
    wParam  : WPARAM,
    lParam  : LPARAM

    .if Msg == WM_INITDIALOG
        invoke LoadIconA, hInst, IDI_MAINICON
        invoke SendMessage, hWnd, WM_SETICON, ICON_BIG, eax
    .elseif Msg == WM_CLOSE
        invoke EndDialog, hWnd, 0
    .elseif Msg == WM_COMMAND
        invoke OnCommand, hWnd, wParam
    .else
        mov     eax, FALSE
        ret
    .endif

    mov     eax, TRUE
    ret
DlgProc endp

;------------------------------------------------------------------------------
;  커맨드 처리
;------------------------------------------------------------------------------
OnCommand proc \
    hWnd    : HWND,
    wParam  : WPARAM

    mov     eax, wParam
    and     eax, 0ffffh

    .if eax == IDOK
        invoke SendMessage, hWnd, WM_CLOSE, 0, 0
    .elseif eax == IDCANCEL
        invoke MessageBox, hWnd, addr MSG1, addr TITLE1, MB_OK
    .endif

    ret
OnCommand endp

;------------------------------------------------------------------------------
;  메인 프로시저
;------------------------------------------------------------------------------
WinMainCRTStartup proc
    invoke GetModuleHandle, NULL
    mov     hInst, eax
    invoke DialogBoxParamA, hInst, IDD_TEST, NULL, addr DlgProc, NULL
    invoke ExitProcess, 0
    ret
WinMainCRTStartup endp

;------------------------------------------------------------------------------
;  End of File
;------------------------------------------------------------------------------
end

위의 프로그램을 어셈블(assemble) 해서 실행해도 다이얼로그 박스는 표시되지 않는다. 왜냐하면, 아직 리소스를 만들지 않았기 때문이다. 다이얼로그 박스를 표시 하기 위해서는, 리소스로서 다이얼로그 박스를 만들어 주어야 한다. 아이콘을 사용한다면, 아이콘 리소스도 필요하다. 만든 리소스를 리소스 컴파일러로 컴파일 해서 실행 파일에 함께 링크 해주어야 리소스를 사용하는 것이 가능해진다. 다음과 같은 리소스를 만들어 보자.

먼저, 다이얼알로그 박스이다.

VC++로 작성하는 경우에는, 다음과 같이 프로퍼티를 설정한다.

프롭퍼티 내용
ID IDD_TEST = 101
Style Overlapped
Border Thin
More Style 「Center」을 체크

다음은, 아이콘이다, 하지만 이것은 마음대로 만들어도 좋다. 이 예제에서는, 다음과 같은 아이콘을 준비했다.

생성한 후 ID는 다음과 같이 지정한다.

ID IDI_MAINICON = 102

이제는, resource.inc 파일을 만든다. 이 파일에는 리소스의 ID를 저장해 둔다.

;******************************************************************************
; 리소스 ID정의 
;****************************************************************************** 
IDD_TEST     = 101 
IDI_MAINICON = 102

마쳤다면, 프로젝트를 빌드 하고 실행해준다. 이제는 화면에 다이얼로그박스가 표시되었을 것이다.


Chapter 5   Tips

개요 : 약간의 Tips

Chapter 5 - 1   인클루드 파일의 종류

지금까지, 대략이나마, MASM로 윈도우 프로그래밍을 접해 보았다.

이번은 조금 다른 얘기로 화제를 돌려보겠다. MASM 는 어셈블러이니까, 어찌보면 어려울 것 같이 생각될 수도 있지만, 실제론 전혀 어렵지는 않다. 오히려 C 를 했던 적이 있는 사람이라면, 아주 쉽게 이해 할 수가 있을 것이다.

MASM로 Windows 프로그래밍을 하는 경우, 함수를 반드시 정의하지 않으면 안된다. 그 함수를 매번 정의해서 사용하는 편보다는, 미리 헤더 파일에 모아 두고 사용하는 편이 더 좋을 것이다.

하지만 프로그래머가 직접 만들어서 사용해도 되지만, MASM32 헤더 파일을 사용하는것이 더편리하다.핵심적인 헤더파일을 설명하겠다.

코어 함수군
Include File 해설
windows.inc Windows 프로그래밍에서 사용하는 대부분의 정수의 정의.
kernel32.inc 커널(코어) 함수. 프로세스 관리, 파일 조작등의 함수가 정의.
user32.inc 유저 함수. 유저 인터페이스 함수의 정의.
gdi32.inc GDI 함수. 그래픽 디바이스 인터페이스 함수의 정의.
advapi32.inc 확장 함수. 암호화, 시큐리티, 레지스트리 조작등의 함수의 정의.
서브 함수군
Include File 해설
comctl32.inc 커먼 컨트롤
comdlg32.inc common dialog
d3drm.inc DirectX 3D Retained Mode
ddraw.inc DirectX DirectDraw
dinput.inc DirectX DirectInput
dplayx.inc DirectX DirectPlay
dsetup.inc DirectX DirectSetup
dsound.inc DirectX DirectSound
glaux.inc OpenGL
glu32.inc OpenGL
imm32.inc IME API
lsapi32.inc LS API
lz32.inc LZ 압축
netapi32.inc NetAPI
odbc32.inc ODBC API
opengl32.inc OpenGL
scrnsavew.inc Screen Saver API
setupapi.inc Setup API
shell32.inc Shell API
tapi32.inc Telephony API
wininet.inc Internet API
winmm.inc Multi Media API
winspool.inc Printer API
wsock32.inc WinSock API

좀 더 있지만, 이 정도로 만족하기 바란다.

Chapter 5 - 2   A와 W의 의미와 함수 호출 규약

함수명의 끝에 A 나 W 가 붙어 있는데 이것의 의미는 무엇일까?

실제로 문자열을 Unicode로 프로그래밍 하는 경우, W가 붙어 있는 함수를 사용한다. A가 붙어 있는 함수는, 문자열을 ASCII 코드로 프로그래밍 한다고 가정하는 것이다.

W 는 Wide 의 W이며 , A 는 Ascii (혹은 ANSI )의 A 이다.(맞겠지?)

MASM로 Windows 프로그래밍 하는 경우, 호출 규약에는 C 호출 규약과 STDCALL 의 호출 규약을 이용한다. 약간의 차이점이 존재한다.

VC++의 경우, 함수는 C 규약으로 통일되어 있다. 함수 수식자로서 __cdecl가 자동적으로 추가된다. API 에서는, __stdcall 로 정의되고 있다.(언더바가 2개이다)

실제로 WINAPI 나 CALLBACK 라고 하는 수식자는 __stdcall 이라고 정의되어 있다. API 로부터 호출되는 것을 생각하면 당연하다.

C 호출 규약과 STDCALL 호출 규약의 차이는, 스택을 오픈하는 추최가 누구인가에 따라 다르다. C는 호출한 측에서 스택을 오픈하고, STDCALL 은 함수의 내부에서 스택을 오픈한다. 다음은 C 와 STDCALL 의 호출 규약의 요약이다.

처리 C
(__cdecl)
STDCALL
(__stdcall)
함수명의 선두에 _ 를 추가
인수를 역순으로 스택에 푸쉬
인수 스택을 호출한 측에서 오픈 ×
인수 스택을 호출된 측에서 오픈 ×
VARARG 사용가능

자세한 부분은 MASM의 도움말을 참조하기 바란다.

Chapter 5 - 3   프로시저의 prototype 선언

함수(프로시저)의 호출을 수행할 경우, invoke 지시어를 사용하면 편하다.하지만 미리 prototype 선언을 수행해 주어야 한다. 또한 invoke 지시어는, 명시적으로 호출규약을 지정해 주어야만 사용할 수가 있다.

invoke 지시어는, 매크로와 비슷한 것으로, invoke를 사용하는 편이 함수호출이 더 수월해진다. 스택 처리를 자동화 해주기 때문이다.

또한, addr 와 offset 는 모두 변수 혹은 정수의 주소를 반환한다.차이점으로는,

offset 지시어만으로 프로그래밍할려면, 상당한 힘든경우가 있다. offset지시어는, 실행시의 스택주소를 얻을수 없기때문이다.이름 그대로, offset 은 식별자의 오프셋(offset)주소를 구해준다.

addr를 사용함으로써 , 실행시의 스택변수의 주소를 얻을 수가 있다.

Chapter 5 - 4   NULL와'\0'

한가지 주의할 것이, NULL = 0 혹은, '\0' = 0 아니다. 확실히, 헤더파일을 보면, NULL = 0 으로 정의되어 있다. 그러나 그것은 편의상 정의된것이므로, 의미적으로는 다르다. 혹시 다른 개발환경에는 NULL = -1 라고 정의되어 있을지도 모른다.

포인터나 핸들등이 정해지지 않았을 경우에는, 반드시 NULL 을 사용하도록 한다. Windows 로부터 구해지는 모든 핸들은, 실제로 (void *) 형태이므로 NULL을 사용하는 이유를 알 수 있을 것이다.

또다시 , C 언어 이야기로 되었지만, '\0'는 문자열의 끝을 나타내는 기호상수이므로, 문자열 외에서 사용해서는 안된다. NULL도 같이 맥락으로 정해진 용도 이외에는 사용하지 않는 것이 좋다.


Chapter 5 - 5   ExitProcess

Windows 프로그램을 종료할 경우에는 반드시, ExitProcess를 호출하도록 하자. 물론, 사용하지 않아도 프로그램을 종료할 수 있다.

하지만, DLL을 호출했을 경우, ExitProcess를 사용하지 않고 프로세스를 종료하면, 프로세스에서 로딩된 DLL이 메모리에 남게된다. ExitProcess를 호출하므로써, DLL에 프로그램이 종료하는 것을 전달되고, DLL도 메모리에서 해제된다.



Chapter 6   텍스트뷰어

개요 : 텍스트뷰어 작성

Chapter 6 - 1   텍스트뷰어 프로그램

지금까지의 단편된 지식을 이용해서, 이번에는 좀 더 실용적인(??) 프로그램을 만들어 보자. 실용적이라지만 단순히 텍스트 파일을 열고 화면에 내용을 표시하는 단순한 프로그램이다. API등의 지식은 MSDN이나 기타참조를 하기 바란다.

만드는 방법은 아주 간단하다. 윈도우의 작업영역에 에디트박스를 생성하면 끝이다.

실제로, WM_CREATE 메세지에서,작업영역에 에디트박스를 생성해주면 된다. 그림으로 표시하면 다음과 같다.

파일을 여는 기능만 수행하여, 파일의 내용을 볼수 있도록만 한다.

프로그램은 다음과 같다. → 프로젝트(VC++용)

 ; --------------------------------------------------------------------
 ;
 ;  Text Viewer main.asm
 ;
 ; --------------------------------------------------------------------
.586
.model flat, stdcall
option casemap:none

include <windows.inc>
include <kernel32.inc>
include <user32.inc>
include <gdi32.inc>
include <comdlg32.inc>

include <resource.inc>

 ; --------------------------------------------------------------------
 ;
 ;  Procedure Definitions
 ;
 ; --------------------------------------------------------------------

InitInstance        proto   hInstance   :HINSTANCE
CreateMyWindow      proto   hInstance   :HINSTANCE
OnCreate            proto   hWnd        :HWND
OnSize              proto   hWnd        :HWND
OnCommand           proto   hWnd        :HWND, 
                            id          :UINT
OnFileOpen          proto   hWnd        :HWND


 ; --------------------------------------------------------------------
 ;
 ;  Data
 ;
 ; --------------------------------------------------------------------

.data

CLASSNAME   DB  'FirstWnd', 0
TCLASSNAME  DB  'EDIT', 0
APPNAME     DB  '텍스트뷰어', 0
FILTER      DB  '텍스트 파일 (*. txt)', 0, '*. txt', 0
            DB  '워드 파일 (*. doc)', 0, '*. doc', 0, 0


g_hEditWnd  HWND    NULL
g_szFile    DB  260 DUP (0)

 
 ; --------------------------------------------------------------------
 ;
 ;  Code
 ;
 ; --------------------------------------------------------------------

.code

 ;******************************************************************************
 ; 메인 함수
 ;******************************************************************************

WinMainCRTStartup proc
    local    msg     :MSG
    local    hWnd    :HWND
    local    hInst   :HINSTANCE

    invoke GetModuleHandleA, NULL
    mov     hInst, eax

    invoke InitInstance, hInst
    cmp     eax, NULL
    je      _Exit

    invoke CreateMyWindow, hInst
    cmp     eax, NULL
    je      _Exit
    mov     hWnd, eax

    invoke ShowWindow, hWnd, SW_SHOWNORMAL
    invoke UpdateWindow, hWnd

 _MsgLoop:
    invoke GetMessageA, addr msg, NULL, 0, 0
    or      eax, eax
    je      _Exit

    invoke TranslateMessage, addr msg
    invoke DispatchMessageA, addr msg
    jmp     _MsgLoop

 _Exit:
    invoke ExitProcess, msg.wParam
    ret
WinMainCRTStartup endp

 ;******************************************************************************
 ; 윈도우 클래스의 등록 
 ;
 ;   ATOM InitInstance hInstance:HISNTANCE
 ;******************************************************************************

InitInstance proc \
    hInstance       :HINSTANCE
    local   wc      :WNDCLASS

    mov     wc.style, 0
    mov     wc.lpfnWndProc, offset MainWndProc
    mov     wc.cbClsExtra, 0
    mov     wc.cbWndExtra, 0

    mov     eax, hInstance
    mov     wc.hInstance, eax
	
    invoke LoadIconA, hInstance, IDI_MAIN_ICON
    mov     wc.hIcon, eax

    invoke LoadCursorA, NULL, IDC_ARROW
    mov     wc.hCursor, eax

    invoke GetStockObject, WHITE_BRUSH
    mov     wc.hbrBackground, eax

    mov     wc.lpszMenuName, IDR_MAIN_MENU
    mov     wc.lpszClassName, offset CLASSNAME

    invoke RegisterClassA, addr wc

    ret
InitInstance endp

 ;******************************************************************************
 ; 윈도우의 작성
 ;
 ;   HWND CreateMyWindow hInstance:HINSTANCE
 ;******************************************************************************

CreateMyWindow proc \
    hInstance   :HINSTANCE

    invoke CreateWindowExA,
        WS_EX_APPWINDOW, 
        offset CLASSNAME,
        offset APPNAME, 
        WS_OVERLAPPEDWINDOW, 
        CW_USEDEFAULT,
        CW_USEDEFAULT, 
        CW_USEDEFAULT, 
        CW_USEDEFAULT, 
        NULL, 
        NULL, 
        hInstance, 
        NULL

    ret
CreateMyWindow endp

 ;******************************************************************************
 ; 윈도우 프로시저
 ;   
 ;   LRESULT MainWndProc hWnd:HWND, Msg:DWORD, wParam:DWORD, lParam:DWORD
 ;******************************************************************************

MainWndProc proc \
    hWnd    :HWND, 
    Msg     :DWORD, 
    wParam  :DWORD, 
    lParam  :DWORD

    .if Msg == WM_DESTROY
        invoke PostQuitMessage, 0
    .elseif Msg == WM_CREATE
        invoke OnCreate, hWnd
    .elseif Msg == WM_SIZE
        invoke OnSize, hWnd
    .elseif Msg == WM_COMMAND
        mov     eax, wParam
        and     eax, 0000FFFFh
        invoke OnCommand, hWnd, eax
    .else
        invoke DefWindowProcA, hWnd, Msg, wParam, lParam
        ret
    .endif

    mov     eax, 0
    ret
MainWndProc endp

 ;******************************************************************************
 ; WM_CREATE 메세지의 처리
 ;
 ;   BOOL OnCreate hWnd : HWND
 ;******************************************************************************

OnCreate proc \
    hParentWnd      :HWND
    local   hInst   :HINSTANCE
    local   rc      :RECT

    invoke GetModuleHandle, NULL
    mov     hInst, eax

    invoke GetClientRect, hParentWnd, addr rc

    invoke CreateWindowExA,
        WS_EX_CLIENTEDGE, 
        offset TCLASSNAME,
        NULL, 
        WS_VISIBLE or WS_CHILD or ES_MULTILINE or ES_AUTOHSCROLL \
        or ES_AUTOVSCROLL or WS_HSCROLL or WS_VSCROLL, 
        0,
        0, 
        rc.right, 
        rc.bottom, 
        hParentWnd, 
        NULL, 
        hInst, 
        NULL
    mov     g_hEditWnd, eax

    invoke SendMessage, g_hEditWnd, EM_SETLIMITTEXT, 0FFFFh, 0

    mov     eax, TRUE
    ret
OnCreate endp

 ;******************************************************************************
 ; WM_SIZE 메세지의 처리
 ;
 ;   void OnSize hWnd :HWND
 ;******************************************************************************

OnSize proc \
    hWnd        :HWND
    local   rc  :RECT

    invoke GetClientRect, hWnd, addr rc

    invoke SetWindowPos, g_hEditWnd, NULL, 0, 0, 
        rc.right, rc.bottom, SWP_NOMOVE or SWP_NOZORDER
    ret
OnSize endp

 ;******************************************************************************
 ; WM_COMMAND 메세지의 처리
 ;
 ;   void OnCommand hWnd:HWND, id:UINT
 ;******************************************************************************

OnCommand proc \
    hWnd    :HWND,
    id      :UINT
    
    .if id == IDM_EXIT
        invoke SendMessage, hWnd, WM_CLOSE, 0, 0
    .elseif id == IDM_FOPEN
        invoke OnFileOpen, hWnd
    .endif

    ret
OnCommand endp

 ;******************************************************************************
 ; IDM_FOPEN 메뉴 메세지의 처리
 ;
 ;   void OnFileOpen hWnd:HWND
 ;******************************************************************************

OnFileOpen proc \
    hWnd            :HWND
    local   ofn     :OPENFILENAME
    local   hFile   :HANDLE
    local   pBuffer :DWORD
    local   dwRead  :DWORD

    ;  파일 오픈 다이얼로그 표시
    invoke RtlZeroMemory, addr ofn, sizeof OPENFILENAME

    mov     ofn.lStructSize, sizeof OPENFILENAME
    mov     eax, hWnd
    mov     ofn.hWndOwner, eax
    mov     ofn.lpstrFile, offset g_szFile
    mov     ofn.nMaxFile, 260
    mov     ofn.lpstrFilter, offset FILTER
    mov     ofn.nFilterIndex, 1
    mov     ofn.lpstrFileTitle, NULL
    mov     ofn.nMaxFileTitle, 0
    mov     ofn.lpstrInitialDir, NULL
    mov     ofn.Flags, OFN_PATHMUSTEXIST or OFN_FILEMUSTEXIST \
            or OFN_HIDEREADONLY

    invoke GetOpenFileName, addr ofn

    or      eax, eax
    je      _OnFileExit

    ; 파일을 연다
    invoke CreateFile, ofn.lpstrFile, GENERIC_READ, 0, NULL, 
        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL
    mov     hFile, eax

    ; 데이터용 버퍼의 확보
    invoke GlobalAlloc, GPTR, 0FFFFh
    mov     pBuffer, eax

    ; 데이터의 해석
    invoke ReadFile, hFile, pBuffer, 0FFFFh, addr dwRead, NULL

    ; 데이터의 기록
    invoke SetWindowText, g_hEditWnd, pBuffer

    ; 버퍼를 삭제
    invoke GlobalFree, pBuffer

    ; 파일 핸들을 닫는다
    invoke CloseHandle, hFile

 _OnFileExit:
    ret
OnFileOpen endp

end

파일을 선택하는 기능은, common dialog의 파일 오픈 다이얼로그를 사용하고 있다. 이것을 사용하는 것으로, 아주 쉽게 파일선택을 할 수가 있다. 자세한 내용은 프로그램을 참조하기 바란다.

빌드 할 때의 주의 사항으로는, common dialog 박스를 사용하므로, common dialog 박스를 사용하기 위해서는, common dialog 박스의 동적 링크 라이브러리(DLL)의 라이브러리를 링크 해주어야 한다. (commlib.lib ?부분 참조 )


Chapter 7   FPU로 수치 연산

개요 : 부동 소수점 연산에 대해

Chapter 7 - 1   부동 소수점 연산에 대해

FPU를(Float Point Unit) 이용한 부동 소수점 연산에 대해, 설명을 한다. 통합 환경으로는 VC++ 를 사용하지만,굳이 VC++가 아니여도 사용할 수 있다. 실제 계산 인스트럭션에 대해서도, 본 설명서에서 자세히 설명하지 않는다. 인텔 메뉴얼을 참조하기 바란다.

이글을 보고 있는 사람은, FPU의 기능을 모르는 사람은 없다는 가정이다. FPU는, 부동 소수점 연산용을 하기 위한 전용 유닛이다. 80386 CPU 까지는 옵션사항이 였지만, 80486부터는 표준으로 CPU내부에 장착되어 있다.

(80486SX는 예외)

FPU에는, 몇개의 레지스터와 전용 인스트럭션이 존재한다. 계산용 레지스터로 8개의 스택타입의 레지스터가 장착되어있다. 계산 인스트럭션에는, 가감승제, 초월함수, 삼각함수 등 수치 계산에 필요한 기능은 대부분 제공되어 있다.

Chapter 7 - 2   FPU용 레지스터

부동 소수점 계산용의 레지스터로 8개의 레지스터가 준비되어 있다. 하지만, 왜 스택형식의 레지스터일까?

실제로 계산을 하려면 스택을 사용하는 것이 여러모로 편하다. 이것은 알고리즘책등에서 스택을 이용해 계산하는것을 본사람도 있을것이다.

실제로 역폴랜드 기법의 계산법으로 프로그래밍 할것이다. 그러므로 레지스터가 몇개 있는지를 의식하지 않아도, 프로그래밍을 해 나갈 수가 있다. (물론 8개를 넘겨서 프로그램을 작성하는 경우에는, 문제가 있다) 이런 방식은 , 스택에 독립적으로 데이터를 읽어들이고,, 역폴랜드식의 계산방법을 무시하고 계산하면, FPU를 사용하는 것기능에도 불구하고 늦어지는 일이 발생할 수 있으므로 주의가 필요하다.

계산시에 특정스택을 다루고 싶은 경우는, st(n)라는 표기법을 사용한다. n 에는, 현재스택으로부터 n 번째의 스택을 지정한다. 예를 들면, 현재 스택 탑으로부터 한단계전의 스택내용을 참조하고 싶은 경우에는, st(1)로 사용한다. 2개전이라면 st(2)로 한다.

다만, 미사용영역의 스택에 액세스 하게되면 에러가 된다.

Chapter 7 - 3   프로그래밍의 방법

실제로, 아래와 같은 계산을 수행해보자.

( 5.98 + 34.89 ) * (34.89 - 23.0)

이 계산을 실제로 부동 소수점 인스트럭션을 이용해서 프로그래밍하면, 다음과 같다.

; _a = 5.98, _b = 34.89, _c = 23.0 으로 한다

fld     _a  ; ①FPU스택에 _a 의 값을 푸쉬
fadd    _b  ; ②현재스택의 값과 _b 의 값을 더한다

fld     _b  ; ③FPU스택에 _b 의 값을 푸쉬
fsub    _c  ; ④현재스택의 값으로부터 _c 의 값을 뺀다

fmul        ; ⑤현재스택과 한단계전의 스택값을 곱해서 한단계전의 스택에 푸쉬

이런 계산을 할 경우, 스택에 실제로 어떻게 데이터가 싸이는지 알아보자.스택은 다음과 같이 운용된다.

Chapter 7 - 4   실제 프로그래밍

그렇다면, 실제로 프로그램을 작성해보자. 수치 연산의 부분을 MASM로 작성하고, C언어로 그 연산을 호출하는 형태로 작성한다. 먼저 C언어의 프로그램은 다음과 같다.

#include <stdio.h>

#ifdef __cplusplus
extern "C" double func(double a, double b, double c);
#endif

int main()
{
    printf("func() = %f\n", func(5.98, 34.89, 23.0));

    return 0;
}

func라고 하는 함수는 MASM로 작성한다. func함수의 내용은 다음과 같다.

.586
.model flat, c

.code

func proc \
    _a: real8,
    _b: real8,
    _c: real8

    fld     _a
    fadd    _b
    fld     _b
    fsub    _c
    fmul

    ret
func endp

end

함수의 반환값은, 스택의 탑에 넣어 둔다.

예를 들어서 다음과 같은 수식을 프로그래밍해보자.

(1) a * (b + c)
(2) |a + b| * sin(c)
(3) a * √(a + b) * cos(c)

각각 다음과 같이 된다.

; (1) a * (b + c)

fld     a
fld     b
fadd    c
fmul

; (2) |a + b| * sin(c)

fld     a
fadd    b
fabs
fld     c
fsin
fmul

; (3) a * √(a + b) * cos(c)

fld     a
fld     a
fadd    b
fsqrt
fld     c
fcos
fmul
fmul

부동 소수점 계산은 이런식이다. 크게 어렵지 않다. 부동 소수점 연산의 에러 처리는, 인텔 메뉴얼을 참조하기 바란다.


Chapter 8   MMX의 SIMD 연산

개요 : MMX를 사용

Chapter 8 - 1   MMX 연산의 개요

■MMX란?

먼저 MMX 명령에 대해 설명한다.

MMX란, 단순한 데이터 요소로부터 대규모 배열에 대한 반복 연산을 수행한다. 용도로는, 동영상, 그래픽, 비디오의 결합, 화상 처리, 오디오 합성, 음성 합성, 압축등이 있다.

말이 어려울 것이다. 실제로 샘플 프로그램을 VC++로 작성해서 알아보자.

■MMX 인스트럭션의 개요

MMX 인스트럭션은, SIMD (Single Instruction , Multiple - Data) 실행 모델이라는 형태를 취한다. 무슨 말인가하면, 하나의 인스트럭션으로 복수의 데이터를 한번에 계산한다는 것이다.

배열 char A[8] 과 char B[8] 라는 배열이 있었다고 가정하자.배열 한개의 요소를 MMX 인스트럭션을 사용하면 한번에 계산 할 수가 있다. 그림으로 설명하면 다음과 같다.

위의 예에서 알 수 있듯이 하나의 인스트럭션으로 한번에 병렬 연산을 수행하게 된다. 이런식으로 화상 처리나 오디오 합성, 음성 합성의 처리 능력을 크게 향상시킬 수가 있다.

MMX는, 8 개의 64 비트 MMX 레지스터 (MM0, MM1, ... MM7)를 가지고 있다. MMX레지스터는, 8개의 FPU 레지스터를 공유해서 사용하므로, 부동 소수점 연산과 MMX 연산을 혼합해서 사용할 경우에는 주의가 필요하다.

MMX 연산에는, 4가지의 데이터형을 계산할 때에 이용한다. Packed Byte/Packed Word/Packed Double Word/Quad Word이다. Packed Byte라는 것은, 64 비트 레지스터를 8비트씩 8개의 영역으로 나눈 형태의 데이터형이다. 그림으로 설명하면, 아래의 그림과 같다. 상자로 둘러싸여 있기 때문에, 팩(Packed)이라고 부른다.

Chapter 8 - 2   MMX를 사용할 수 있는지 체크

MMX를 사용하기 전에 MMX 인스트럭션을 사용할 수가 있는지 체크 할 필요가 있다.

체크루틴에는 CPUID 인스트럭션을 사용한다. 구체적인 프로그램은 다음과 같다.(인라인어셈 사용)

/* CPUID의 존재 체크 */

BOOL IsCPUID()
{
    DWORD dwPreEFlags, dwPostEFlags;

    _asm {
        /* EFlags 의 값획득 */
        pushfd
        pop     eax
        mov     dwPreEFlags, eax

        /* CPUID 인스트럭션의 존재체크 (ID 플래그 체크) */
        xor     eax, 00200000h
        push    eax
        popfd

        /* EFlags 의 값의 획득 */
        pushfd
        pop     eax
        mov     dwPostEFlags, eax
    }

    if(dwPreEFlags == dwPostEFlags)
        return FALSE;
    return TRUE;
}

/* MMX 가능여부 체크 */

BOOL IsMMX()
{
    DWORD dwRetEDX;

    /* CPUID 인스트럭션 체크 */
    if(! IsCPUID()) return FALSE;

    /* MMX 가능여부 체크 */
    _asm {
        mov     eax, 1
        cpuid
        and     edx, 00800000h
        mov     dwRetEDX, edx
    }
    if(dwRetEDX) return TRUE;
    return FALSE;
}

Chapter 8 - 3   포화 연산·비포화 연산

MMX 연산에는 포화 연산과 비포화 연산이 있다. 포화 연산은, 연산으로 오버플로우/언더 플로우(underflow)가 발생했을 경우 그 최대값/최소값을 자동으로 대입해 주는 연산이다. 비포화의 경우는 그것을 수행하지 않는다.

구체적인 예를 들겠다. Packed Byte에서 MMX 무부호 연산을 생각해 보자. 한개의 요소가 240 + 23 = 263 으로, 오버플로우가 발생 했을 경우, 자동으로 최대값을 대입해 준다. 즉 이 경우는, 255 가 대입된다. 다음의 그림을 보면 이해할 수 있을 것이다.

덧붙이면 PADDUSB 라는 것은, 무부호 포화 가산 연산을 수행하는 MMX 인스트럭션이다. (Packed Add Unsigned with Satuation Byte)

MMX 인스트럭션에는 다음과 같은 것이 있다. 간단히 설명한다.

데이터 전송 인스트럭션
MOVD 32 비트 데이터 전송 인스트럭션
MOVQ 64 비트 데이터 전송 인스트럭션
산술 가감(상태) 연산 인스트럭션
PADDx / PSUBx 비포화 연산 인스트럭션 x = B(BYTE) / W(WORD) / D(DWORD)
PADDSx / PSUBSx 부호 첨부 포화 연산 인스트럭션 x = B(BYTE) / W(WORD)
PADDUSx / PSUBUSx 무부호 포화 연산 인스트럭션 x = B(BYTE) / W(WORD)
곱셈 인스트럭션
PMULHx / PMULLx 곱셈 인스트럭션 x = W(WORD) / D(DWORD)
논리 연산 인스트럭션
PAND / PANDN / POR / PXOR  
쉬프트 명령
PSLLx / PSRLx 좌/우논리 쉬프트
PSRAx 오른쪽 산술 쉬프트
변환 인스트럭션
PACKSSxx 부호화 포화 팩화 xx = WB / DW
PACKUSxx 무부호 포화 팩화 xx = WB
PUNPCKHxx 상위 unpack화 xx = BW / WD / DQ
PUNPCKLxx 하위 unpack화 xx = BW / WD / DQ
제어
EMMS MMX 의 종료

마지막의 EMMS 인스트럭션은, MMX의 사용을 종료했을 때에 반드시 수행해야 한다. MMX는 FPU의 레지스터를 공유해서 사용하므로, 명시적으로 레지스터를 EMMS 인스트럭션으로 초기화해 두지 않으면 안 되기 때문이다.

Chapter 8 - 4   실제 프로그램·알파블렌딩

실제로 MMX를 사용해서 연산해 보자. 이번에는 2개의 데이터의 덧셈을 실시한다. 만약 화상자료일 경우라면,「알파블렌딩(Add Alpha-Blending)」이라는 기술이다.(반투명 처리)

 /* Dest = Dest + Src 를 수행한다
 * 데이터의 길이는 8의 배수여야만 한다
 */

void AddData(BYTE *lpDestBuf, BYTE *lpSrcBuf1, BYTE *lpSrcBuf2, DWORD nLength)
{
    _asm {
        /* 초기화 */
        mov     ecx, nLength;
        shr     ecx, 3
        mov     edi, lpDestBuf
        mov     ebx, lpSrcBuf1
        mov     edx, lpSrcBuf2

        /* 루프 연산 */
    ADD_LOOP:
        movq    mm0, [ebx]
        movq    mm1, [edx]

        /* 데이터 가산 */
        paddusb mm0, mm1

        /* 결과를 저장 */
        movq    [edi], mm0

        /* 증감(increment) */
        add     edi, 8
        add     ebx, 8
        add     edx, 8

        dec     ecx
        jnz     ADD_LOOP

        /* MMX 종료 */
        emms
    }
}

이런 간단한 예제로, MMX에 대해서 안다는 것은 불가능하다. 이런 부분을 기초로 해서 응용해 나가면, 화상 처리와 같은 부분에서 처리능력을 크게 개선할 수가 있다. 자 이제부터는 스스로 여러가지 프로그램을 짜 보고 실감해 보기바란다.

신고
크리에이티브 커먼즈 라이선스
Creative Commons License
TAG MASM, VC++ 6.0
 

※본 글은 전적으로 강팩(alzardzero@gmail.com)과 모베(www.mobe.co.kr)에 저작권이 있습니다.

※퍼가실때는 원문 그대로 퍼가시기바랍니다.
※궁금증은 www.mobe.co.kr의 질문게시판에 글을 올려주세요
※틀린점이 있거나, 추가했으면 하는것들은 제 메일로 보내주시거나 혹은 덧글을 달아주시기바랍니다.(검토후 반영하겠습니다)
※이 글의 대상자는 PDA에서 윈도CE, WM이 헷갈리시는분입니다. 중급자 이상은 읽으실 필요가 없을거같습니다..



Windows CE의 간략한(?) 소개글


(Third Edition.D Ver06.05.11 Made by 강팩 <MOBE.co.kr> )


※절대로 Windows CE는 PDA만을 위한OS가 아님을 꼭 알아주시기바랍니다. 즉 CE를 탑제했다고 해도 CE의 모습을 없애고 각 회사에서 만든 쉘을 사용하여 출시한 제품도 있으니, 모든 기기에서 CE프로그램 사용이라던지, 이런것들이 불가능 한 기기도 있음을 알려드립니다.   (ex. 세가社의 드림캐스트 게임기.)



-- 목차 --

Chapter 1.줄인 용어들
Chapter 2.Windows CE란?
Chapter 3.Windows CE시리즈의 역사
Chapter 4.Windows CE시리즈의 종류
Chapter 5.CE와 PPC(WM)호환성

Chapter 6.Windows CE와 Windows Mobile 의 차이점
Chapter 7.용어 설명



-- Chapter 1.줄인 용어들 --
Windows CE - Win CE
Pocket PC - PPC
Windows Mobile - WM
Platform Builder - PB
Hand held PC - HPC


-- Chapter 2.Windows CE란? --
Windows CE는 Microsoft사가 개발한 임베디드 운영체제의 브랜드명이다.
PC 윈도와 같이 Windows라는 명칭을 사용하지만 Windows CE는 그 내용이 기존의 OS와는 아주 차이가 있습니다.

가장 큰 차이점은 Windows CE가 돌아가는 방식에 있지요.
PC의 Windows OS는 따로 OS CD가 있어 아무 컴퓨터나 CD를 넣고 설치를 함으로써 Windows에서 각 부품별 드라이버만 잡아주면 제대로 돌아가게 되어있지만, Windows CE라는 OS는 Windows 상에서 Platform Builder라는것으로 제작을 하는것인데, 여기서 주의할점은 Windows CE OS 구동방식은 오히려 PC 윈도보다는 휴대폰쪽에 있다고해야합니다.
무슨말이냐 하면 Windows CE는 휴대폰 처럼 각각의 기기에 맞게 LCD드라이버, 사운드 드라이버 등과 같은것들을 따로 제작해주어야하며, 이 기기 전용이면 이 기기에만, 저 기기 전용으로 나온 OS라면 저 기기에만 적용이된다는것이 가장 차이가 있습니다.

그리고 이 Windows CE가 탑제된 기기는 PC와는 다르게 업그레이드가 거의 불가능하다는 점이 있습니다. 뭐.... 기술만 있으면 메모리 정도는 가능하겠지만요 ^^;

이 Windows CE는 용도에따라 3가지로 분류 할 수 있습니다.
Embedded OS계열은 다용도로 쓰이는것으로써 게임기,PDA,네비게이션,DVD플레이어,CD플레이어,DVD플레이어, VoIP폰, 산업용기기 등과 같은곳에 쓰입니다.
세가의 드림캐스트 게임기도 Win CE가 탑제되었습니다만, 전혀 윈도의 모습을 찾을 수 없지요 ^^ 그게 임베디드OS의 특징입니다. 만들고 싶은대로 만들거나 기본틀을 멋대로 바꿀 수 가 있다는거지요. 그러나 그에 비해 다음에의 OS들은 규격화가 되어있어 그 규격에 맞게 제작해야합니다.

먼저 Pocket PC (Windows Mobile)라는 OS가 있습니다.
이쪽은 iPAQ, Mits M400/4000, POZ시리즈, 도시바 E시리즈,AXIM,룩스 등과 같은 PDA에 적용이 됩니다.

HPC OS도 있습니다.
HPC는 원래는 키보드가 있는 노트북같은 형태를 띠며 해상도가 640x240인 제품을 HPC라고 하시만.. 요즘은 뜻이 약간 변질(?) 되어 해상도가 크며, PC 윈도와 같은 모습을 하고있는 PDA를 대부분 HPC라고 합니다.
HP조나다 680/710/720과 NEC 모디아/모바일프로시리즈, NTT도코모 시그마리온1/2
등이 이에 포함됩니다.

Auto PC OS는 요즘은 많이 쓰이지 않는것으로써..... 거의 찾아보기 힘듭니다 ^^;;
이부분에 대해서는 생략하겠습니다... (극히 소량의 정보밖에 찾질 못하겠습니다...)
(클라리온에서 차량용 오디오에 탑제되었었고, 몇몇 네비게이션기기에 탑제된 적이 있다는것 외의 정보는 없네요;;)

-- Chapter 3.Windows CE시리즈의 역사 --

마이크로소프트는 Pen windows (펜의 조작으로 컴퓨터를 작동시키려는 방법), 그리고 ITV (Microsoft Interactive TV) 라고 불리는 몇 가지 프로젝트를 진행하는 도중 실패를 맛보게 됩니다. 그러나 1996년 PDA시장상황을 새롭게 변혁시켜 놓은, Palm의 등장때문에 뭔가 압박을 받아서 개발을 한 것 같습니다...
윈도 CE는 96년도에 버전 1.0으로 처음 모습을 드러냈습니다.
국내에서는 LG의 모빌리안이라는 제품이 Windows CE1.0을 탑제했습니다.
그때는 흑백에 뭐.... 지금의 CE계열과는 다른모습입니다. 뭔가가 많이 부족하던 시절이었죠...^^;
이 부족한 기능을 보완하기 위해 97년 봄에 Windows CE2.0 이 나왔습니다.
바뀐 부분은 다음과 같습니다.
-a. 256 컬러 또는 16 gray 흑백 화면의 지원
-b. 최대 640x240 해상도의 화면까지 지원
(이것 때문에 HPC라는 개념이 나오게 됩니다. 모바일 프로780도 CE 2시리즈를 쓴답니다..)
-c. Pocket PowerPoint를 기본 탑재
-d. Pocket Outlook의 동기화 성능 향상
-e. TrueType 폰트의 지원
-f. Print 기능의 지원

※연이어 97년 봄에 2.0의 버그와 기타 오류를 수정해서 CE 2.11과 2.12가 출시되었습니다.
2.11과 2.12의 뒤에 숫자는 단지 지원하는 시피유 차이라고 합니다.

그리고 약 2년동안의 공백기간을 갖고 99년에 나온것이 Windows CE 3.0입니다.
Win CE 3.0에서는 총 3가지 버전인 CE 3.0 Embedded / HPC 2000 / Windows for Pocket PC가 있습니다.
그러나 같은 CE3.0계열들이라도 이들은 호환되지 않습니다만, 요즘에는 dll파일을 넣어 약간은 구동이 되긴 합니다. 차라리 호환성을 유지하게 OS를 통합하였으면 나았을껄 하는 생각이...
돈에 눈이 먼 MS라 일부러 저렇게..
Embedded는 넥시오 s150/151과 PC-ePhone1/2 등이 대표적인 모델입니다.
HPC2000은 정말 업무용에 최적화 되어있어, 파워포인트, 엑셀, 엑세스, 워드가 포함되어 있습니다.
Windows for Pocket PC는 PPC2000입니다.
대표 모델은 iPAQ h3630/3660/3130, 카시오페아 e105/110/125/em500등입니다.
작은사이즈에 맞게끔 최적화해서 나온것이 특징입니다.

2001년 드디어 CE계의 Win XP인 CE.NET4.0이 등장했습니다.
1. 인터넷 익스플로러 5.5 채택
2. Windows Media Player 8.5내장
3. MSN 인스턴트 메신저 내장
4. 3.0보다 더 나아진 전력관리
5. 신형 CPU (인텔 PXA시리즈와 같은 ARMV4i혹은 그 이상급)에 대한 최적화
등이 대표적인 특징입니다.
차기 버전인 4.0에서도 이전버전의 PPC OS와의 호환성은 별로 없습니다.

같은해에는 PPC2000의 업그레이드 버전인 PPC2002가 탄생하였습니다. 이것 역시 CE 3.0 기반입니다. 이 때 PPC만의 호환성이 유지됩니다. 투데이라는 화면에다가 *.tsk이라는 테마파일 지원 등등...

2002.10에는 CE.net 4.1이 나왔지만 겉보기에는 다른게 없습니다. 내부적으로 향상만..

2003.9 Pocket PC와 호환성을 높였다라는 이름하에 CE.net 4.2가 나왔습니다.
1.인터넷 익스플로러 6 호환
2.미디어 플레이어 9 내장
3.PPC와의 호환성
이 특징입니다만, 정작 PPC와의 호환성은 그리 없습니다. 단지 호환성은 각 제조회사에 달려있다고만...... 특히 PPC의 해상도인 240x320급 이상으로 만들어 진 기기는 더욱 어렵습니다...

한달 뒤, PPC계에서는 Windows Mobile 2003을 내놓았습니다.
1. 미디어 플레이어 9 채택
2. 인터넷 익스플로러 6호환
3. 신형 시피유에 대한 최적화로 인한 속도 향상
4. 전력소모량 감소
등이 대표적으로 두드러진 특징입니다.

2004년 9월즘에는 WM2003 Second Edition을 출시 하였습니다.
1.640x480 해상도 지원
2.미디어 플레이어 버전10 지원 (wmp9.0 혹은 10.0이 탑제됨)
3.화면돌리기(Landscape)지원

그리고 조금뒤(?) Windows CE 5.0이 출시되었습니다.
1.미디어 플레이어 버전10 지원 (wmp9.0 혹은 10.0이 탑제됨)
2.네트워크쪽 향상
3.다이렉트x 라이브러리 추가로 인한 엔터테인먼트 강화
4.Windows Mobile과 같은 코드 및 라이브러리 사용 및 라이브러리 대거 추가


그 뒤를 잇달아 2005년 3/4분기쯤에 Windows Mobile 5.0이 등장했습니다.

1. Direct3D Mobile과 DirectDraw로 인한 풍부한 graphic및 multimedia 지원
GPS data를 동시 access하기 위한 multiple 어플리케이션 제공과 사용하기 쉬운 API를 포함한 GPS 장비를 위한 통합지원
2. 두 개의 새로운 API를 통한 통합지원. Camera Capture API는 사용하기 쉽고, 사진을 보거나 찍는데 고급 API입니다 ; 카메라 하드웨어의 상세한 Control을 필요로 하는 개발자를 위해 DirectShow도 가능합니다.
3. 프로그램이 custom data를 저장하고, Outlook Data의 변화에 따른 Notification을 등록하는 능력을 포함한 강력해진 Pocket Outlook API.
4. 쉽게 보고, 작성하고, 메시지를 보내는 기능을 제공하기 위한 새로운 메세징 API .
5. GetDeviceUniqueID를 통한 장비의 unique identifier를 Access.
6. 새로운 File-Based DRM 관리 API를 통한 DRM 프로그래밍 모델
7. State, Notification Broker API 제공을 통한 Incoming phone call 또는 network 연결이 가능한지와 같은 시스템 status의 변화를 탐지하기 위한 일반적인 Architecture

8. 배터리 방전시에도 데이터 보존가능.

9. Today화면의 하단 UI변경


그리고 올해(2006년)쯤에 Windows CE 6.0이 나온다고하네요.

 2007년에는 Windows Mobile 6.0이 나올거라는 소식도 있습니다.



-- Chapter 4.Windows CE시리즈의 종류 --

출시된 순서대로...

Windows CE 1.0
Windows CE 2.0 / 2.11 / 2.12 / HPC / HPCPro
Windows CE 3.0 / HPC2000 / PPC2000 / AutoPC
Windows CE .NET 4.0 / PPC2002 based on CE 3.0
Windows CE .NET 4.1
Windows CE .NET 4.2 / Windows Mobile 2003 based on CE .NET 4.2
Windows Mobile 2003 Second Edition based on CE .NET 4.2 / Windows CE 5.0
Windows Mobile 5.0

Windows CE 6.0

-- Chapter 5. CE와 PPC(WM)호환성 --

CE.net과 PPC&WM과 다른 OS가 아닙니다. CE를 기초로 Windows Mobile가 만들어 진거구요.
그리고 CE와 PPC와의 호환성도 전혀 없는것이 아닙니다.
몇가지 dll과 파일 수정을 거치면 CE.net 4.2 이상에서는 대부분 사용가능합니다.

그리고 OS만 CE를 사용했을뿐 라이브러리라던지 뭐.. 기타 PPC프로그램에 대한 호환성을 제조사에서 OS제작시에 높였을 수도 있구요.

결론은 돌아가는 프로그램에서는 Today Plugin 파일 혹은 PhatPAD라던지 몇몇 프로그램을 제외하면 비슷비슷하다는것 입니다.


-- Chaper 6.Windows CE와 Windows Mobile 의 차이점 --

차이점은 우선 WM은 일단 통일된 라이브러리 덕분에 WM OS를 쓰는 PDA라면 99.9% 프로그램 호환이 가능합니다. 겉모양도 비슷비슷합니다.

그러나 CE는 일단 그 목적이 PDA에게만 맞춰진 OS가 아니기에 회사에서 어떻게 제작하느냐에 따라 OS의 특성이 달라집니다. 그로인하여 같은 CE를 사용하더라도 기기간에 프로그램 호환성이 WM처럼 높지않습니다. 그렇지만 dll파일 추가라던지 이런것을 통해서 호환성을 높일 수는 있습니다.

겉모습도 많이 다릅니다.

CE의 경우는 제작하기나름(기본적으로는 Windows XP Classic UI를 따르고있습니다.), WM는 통일된 모습을 보여주고있습니다.



-- Chapter 7.용어 설명 --

*Platform Builder-PB : Win CE os를 제작하는 도구
*Hand held PC - HPC : 키보드가 달려있으며 노트북 같이 되어있음. 640x240해상도로 규격화. 넥시오는 Embedded기기 라고 봐야함. 그러나 개념의 변화로 넥시오, 시그마리온3 등의 기기도 HPC로 분류.
*라이브러리 : 일종의 프로그램이 돌아가게 만드는 소스같은거라고 할까요 ? ^^
이것이 주 축이 되어서 CE프로그램이 돌아가게 하는것입니다 ^^





--------------------------------------------------------------------

※ Windows CE, Windows Mobile, Pocket PC, Hand-held PC, Palm-sized PC등등 이 있는데

시스템 등록정보에서 윈도 버전이 예를들면 PPC2002랑 Win CE3.0을 비교했는데 3.0.xxx라고 동일하게 표기되어있는 이유는 다 같은 Core(일종의 심장이죠..)를 쓰고있기에 같습니다.

신고
크리에이티브 커먼즈 라이선스
Creative Commons License
사용자 삽입 이미지


세계에서 200팀 뽑는데 거기에는 일단 들어 갔다.
이제 부터 시작이다. 5월 18일까지 결과물을 내야 한다.
영어를 공부한다고 한다고 한다고 한다고 했고 학점을 올린다고 올린다고 했는데
또 일을 벌려 버렸다.흐미..........
영어 학점 대회 os 등등등..... 할껀 많지만 다 해버리지머............
신고
크리에이티브 커먼즈 라이선스
Creative Commons License

ASM 강의록

분류없음 2007.03.09 18:04 by LoofBackER
강의록
신고
크리에이티브 커먼즈 라이선스
Creative Commons License
TAG ASM

뭐?  
어렵게만 여겨지던 운영체제의 베일이 벗겨지고 있습니다. 이것도 유행일까요?
소프트웨어 개발자라면 알고 싶어지고, 구현해 보고픈 운영체제. 그속을 들여다보고
연구하며 스스로 제작해 보는 사이트들이 계속 늘고 있습니다. 저역시 그 만들기의
시작을 조심스럽게 열어 보려 합니다. 여기-저기, 이곳-저곳, 앞-뒤-옆집에서 짬짬히
얻은 정보들을 토대로(어쩌면 짜집기(^^)로 보일 수도 있지만) 한몫 해보고픈 마음에 글을 써 봅니다.

아래의 내용들은 제가 직접 작성한 부트섹터 코드의 간단한 설명과 컴파일 방법
그리고 x86 Protected Mode로 포팅된 μC/OS-II소스를 가지고 빌드하는 설명을 가지고 있습니다.

이 강좌는 절대로 기술적인 내용이 없습니다. 어셈코드의 지식과 부트섹터, 커널에
관한 어느정도의 지식을 갖추었다는 가정하에 내용을 진행하게 됩니다.
단지 예제로 제시한 코드를 컴파일 하고, 실제 운영체제처럼 동작하는 모습을 보여줌 으로써
Visual C++환경하에서도 운영체제 개발 작업을 할 수 있다는 것을 보이기 위함입니다.
만약, 그러한 것들의 개념이 필요하다면 먼저 위의 메뉴에서 PROJECT -> OS PAGE에 링크된
여러 자료를 참고 하시기 바랍니다. 물론 예전에 Bellona라는 운영체제를 만드신
 오재준님의 강좌와 서적이 이와 유사합니다만, 그 내용에는 VC 5.0의 환경과 조금은
복잡한 부트섹터에 의해 커널이 로드됩니다. 나름대로의 이유가 있겠습니다만, 그와는 상관없이
이 강좌는 순수하게 VC 6.0의 환경에서 커널제작이 가능함을 보이기 위한 내용임을 다시 한번 주지시켜 드립니다.
 


준비물  
 


 - 환경
	Microsoft Windows® 98, 2000, XP에서 테스트 되었습니다. 

 - Tool
	Borland-C++® 3.0(2.0도 됩니다^^) [Turbo-C® 2.0 download]
	Microsoft Visual C++® 6.0
	Microsoft Macro Assembler® 6.11 (다른 버전은 안됩니다.)
	NASM 0.98.36 (다른버전도 괜찮을지(?) 모릅니다.^^) [NASM site link]

 - Source
μC/OS-II(Port : x86 Protected Mode) [UCOS-ii(intel port) Site link]
LestatOS(TM) Boot Sector [bootsect.asm download]
: 장진호(devilnis@nownuri.net)님께서 고맙게도 버그를 하나 지적해 주셨습니다. 
Boot Sector를 디스켙의 젤 첫섹터에 옮겨주는 C 소스 [scopy.c download] 윈도우 환경에서 부트 섹터 정보를 읽고 써주는 유틸리티 [GSector.exe download]


구성  

우리가 빌드해볼 전체 목록 구성은 대충 이렇습니다.

- μC/OS-II 커널 이미지
- 커널 이미지를 로드할 부트섹터

위의 준비물들은 모두 예제로 다뤄볼 위에서 나열한 운영체제와 부트섹터를 빌드하기
위함입니다.
μC/OS-II 커널 이미지를 빌드하는 방법은 UCOS-II 웹 사이트의
http://www.ucos-ii.com/intel/index.html 페이지를 참고하시면 됩니다. 거기엔
Jean Louis Gareau가 제작한 부트섹터와 커널이미지 그리고 커널이미지 로더 소스와
태스크 소스가 있습니다. 이를 참고로 하는 이유는 장점이 커널제작 작업을 Visual C환경에서 할 수 있다는 것입니다.
	

μC/OS-II
에 관해 좀 더 알고 싶으시다면, http://www.ucos-ii.com사이트를 참조하시기
바랍니다. 아주 소형인 리얼타임 커널이면서도 탁원한 스케쥴링 알고리즘과 여러 시스템에
 유연하게 포팅된 운영체제입니다.


 ::TOP


구현  
 

자, 그럼 시작합니다!
제가 제작한 부트섹터는 NYAOS부트섹터를 참고했습니다.
부트섹터 설명 : bootsect.asm

부트 섹터는 BIOS에 의해 (물리주소)0x7C00번지에 로드 됩니다. 512 BYTE의 크기를
가져야 하며, 파일의 끝은 0x55,0xaa캐릭터가 포함됩니다. 그리고 디스크의 젤 첫번째
섹터에 위치시키면 되는데요, 이왕이면 파일시스템정보를 포함함으로써 윈도우/리눅스나
도스등에서 접근할 수 있는 편리함을 이용해도 되겠죠. 무슨 말이냐 하면, 커널 이미지를
나중에 완성해 보시면 아시겠지만, 이미지를 특정 섹터에 위치 시켜 두고 부트로더가
로드하는 방식은 소스가 간단할 수도 있지만, 업데이트 된 커널을 매번 그렇게 위치시키느니
차라리 적당한 파일이름으로 복사만 시켜 주더라도 부트섹터가 알아서 커널을 로드한다면
많이 편하다는 것을 느끼실 겁니다. 그렇기에 부트섹터의 소스 첫부분은 파일시스템 정보를
채웁니다.
1 fatOEM       db "LestatOS"               ; OEM  
2 fatSectSize  dw 0x200                    ; Bytes per sector = 512  
3 fatClustSize db 1                        ; Sectors per cluster  
4 fatRessect   dw 1                        ; # of reserved sectors  
5 fatFatCnt    db 2                        ; # of fat copies  
6 fatRootSize  dw 224                      ; size of root directory  
7 fatTotalSect dw 2880                     ; total # of sectors if < 32 meg  
8 fatMedia     db 0xF0                     ; Media Descriptor  
9 fatFatSize   dw 9                        ; Size of each FAT  
10 fatTrackSect dw 18                       ; Sectors per track  
11 fatHeadCnt   dw 2                        ; number of read-write heads  
12 fatHidenSect dd 0                        ; number of hidden sectors  
13 fatHugeSect  dd 0                        ; if fatTotalSect is 0 this value is  
14                                         ; the number of sectors  
15 fatBootDrv   db 0                        ; holds drive that the fat came from  
16 fatReserv    db 0                        ; not used for anything  
17 fatBootSign  db 29h                      ; boot signature 29h  
18 fatVolID     dd 0                ; Disk volume ID also used for temp  
19                                         ; sector # / # sectors to load  
20 fatVoLabel   db "LestatOS",13,10,0       ; Volume Label  
21 fatFSType    db "FAT12   "               ; File System type  
view plain | print | copy to clipboard | ?

 물론 부트섹터가 하는 젤처음 동작은 점프입니다. 확장자가 COM인 파일의 포멧과 비슷합니다. 점프를 끝내고 인터럽트를 디스에이블 시킨 후 현재 부트된 드라이브의 정보를 얻어 옵니다. 즉, 바이오스는 DL레지스터에 현재 부트된 드라이브의 정보를 담아 둡니다. dl0x00이 들어있으면 A드라이브, 0x80이면 C드라이브 입니다.
1 mov ax,0x9000                ; put stack at 0x91000  
2 mov ss,ax  
3 mov sp,0x1000  
view plain | print | copy to clipboard | ?

 그런다음 위처럼 스텍공간을 잡아 줍니다. 넉넉히 메모리의 저 위쪽으로 말이죠^^
이후, 플로피 컨트롤러를 초기화 하고, 에러면 에러 메세지를 출력하면서 리붓을
한다거나 하는 루틴은 먼저 말씀드린 NYAOS의 부트섹터 소스 설명을 참고 하시구요(^^).
본인이 수정/삽입한 중요 부분들의 설명을 이어 나가겠습니다.^^
1 MOV AX,0x8000           ;80000번지로 이동...  
2 MOV ES,AX                                
3 XOR DI,DI                                
4 MOV AX,0x07C0                              
5 MOV DS,AX                                
6 XOR SI,SI                                
7 MOV CX,0x0100                              
8 REPZ                                         
9 MOVSW                
10              
11 JMP 0x8000:go       ;0x8000:go 의 위치로 점프              
12              
13   go:   mov ax,0x8000  
14 mov ds,ax    
view plain | print | copy to clipboard | ?

 위의 코드는 현재 메모리의 0x07c0:0x0000의 위치에 있는 부트섹터 코드를 물리주소0x80000번지로 이동시킵니다. 이동이 끝난후 당연히 수행된 코드의 다음으로 점프를 해야겠죠? 그렇기에 JMP 0x8000:go 명령을 내립니다. 그리고 DS레지스터를 이동된 세그먼트 위치 0x8000으로 세트 합니다.
	
이후, 루트 디렉토리부터 파일이름으로 지정된 커널이미지를 검색하고, 찾으면
물리주소0x40000번지에 이미지를 로드 합니다. 커널이미지 까지 로드된 메모리의
모습은 아래와 같습니다.
	
그런 다음 플로피 디스크 드라이브의 모터를 아래의 코드와 같이 끄고,
1 mov al, 0x0c  
2 mov dx, 0x03fe  
3 out dx, al  
view plain | print | copy to clipboard | ?

최총적으로 커널 이미지를 다시 최하위 0x0000:0000번지로 이동 시킨 후, 물리주소
0x01000번지로 점프 합니다. 0x1000번지부터 커널이미지의 실제 코드가 시작되기
때문입니다. (컴파일 된 커널이미지를 덤프해 보시면 압니다.^^)
1 cli  
2              
3 MOV AX,0x0000           ;40000번지에서 0x0000:0000으로 이동...  
4 MOV ES,AX                                
5 XOR DI,DI                                
6 MOV AX,0x4000                              
7 MOV DS,AX                                
8 XOR SI,SI                                
9 MOV CX,0x7000                              
10 REPZ                                         
11 MOVSW                      
12              
13 mov ax,0x0000               ; set segment registers and jump  
14 mov es,ax  
15 mov ds,ax  
16 jmp 0x0000:0x1000  
view plain | print | copy to clipboard | ?

 아래의 그림은 부트섹터와 커널이미지가 로드된 후 전체적인 호출 순서를 보여 줍니다.
제일 먼저 부트섹터는 Entry.asm에 의해 컴파일 된 Entry.obj로 점프하게 되며
Entry.obj는 커널의 main함수를 호출하게 됩니다.
Entry.asm이 하는 일은 CPU를 보호모드로 변환함과 동시에 GDT,IDT를 세팅하는
역할을 합니다. 그작업이 끝나면 곧바로 커널의 main함수를 호출합니다.
	



실전! (Build)

네^^; 이제부터 실제로 부트섹터와 운영체제를 빌드해 봅시다. 먼저, 부트섹터를 컴파일
하는 방법은 아래와 같습니다. nasm이 당연히 설치되어 있어야 겠죠?
: (bootsect.asm 컴파일 방법)
	
부트섹터를 디스켙의 첫번째 섹터에 옮기는 방법은 몇가지가 있습니다. 예를 들면 도스의
디버거에서 아래와 같이 하셔도 상관없습니다.
: (bootsect를 디스켙의 첫번째 섹터에 옮기는 방법)
	
그렇지만, 좀더 멋지게- 우리만의 운영체제 인스톨러를 만들고 싶다면, 부트섹터를 복사
해주는 코드를 가지고 있어도 나쁘진 않겠죠? scopy.c의 코드는 아래와 같이 간단합니다.
1 //***************START************************  
2 #include "bios.h"  
3 #include "stdio.h"  
4  
5 void main()   
6 {   
7           FILE *in;   
8            unsigned char buffer[520]; /* 버퍼를 잡고 */  
9  
10         if((in = fopen("bootsect", "rb"))==NULL) /* bootsect 파일을 바이너리로 연다음 */ 
11         {   
12                 printf("Error loading file\n");   
13                 exit(0);   
14            }   
15  
16         fread(&buffer, 512, 1, in); /* 512바이트를 읽고 */ 
17  
18            while(biosdisk(3, 0, 0, 0, 1, 1, buffer)); /* 디스크의 첫섹터에 씁니다 */ 
19  
20         fclose(in);   
21 }   
22 //***************E N D************************  
view plain | print | copy to clipboard | ?
아래의 방법으로 scopy.c를 컴파일 합니다.
: (scopy.c 컴파일 방법)

컴파일된 scopy.exe와 같은 디렉토리에 컴파일된 bootsect파일이 있으면 단지,
scopy.exe를 실행하는 것만으로 디스켙의 첫번째 섹터에 bootsect가 옮겨집니다.

그리고, Entry.asm을 컴파일 해야겠죠? nmake가 세팅되어 있다면, Entry.asm디렉토리에서 아래그림과 같이 nmake만 실행하면 됩니다.
: (Entry.asm 컴파일 방법)

만약, 그렇지 않다면, 아래 그림처럼 ml.exe 파일을 Entry디렉토리에 복사한 후 옵션과
함께 ml.exe를 실행합니다.
: (Entry.asm 컴파일 방법)

ml.exePath되어 있다면, Visual C에서 MyTask.dsw 프로젝트는 제대로
컴파일이 되어 MyTask.IMG 파일을 생성할 겁니다. 만약 그렇지 않다면, ml.exe
MyTask디렉토리에 복사한 후에 F7키를 눌러 빌드하세요.
(물론! 프로젝트 리소스 탶에서 os_cpu_a.asm를 선택하고 Project -> Setting에서
컴파일러 패스를 수정하셔도 됩니다.)


자, 이제 빌드는 모두 끝났습니다. 부트섹터까지 디스켙에 옮겼다면, MyTask.IMG파일만
디스켙에 복사해 주면 됩니다. 만약, MyTask.Img라는 커널이미지 이름이 마음에
안든다면 bootsect.asm의 소스코드의 젤 아랫줄 근처를 보시면 'MyTask__IMG'라는
데이터가 보일겁니다. 이부분을 12칸에 맞춰서 바꿔 주시면 됩니다. 즉, 커널이미지를
1.IMG라는 파일로 명명하고 싶다면, '1_______IMG'로 바꾸시면 됩니다.
(여기서 '_'는 공백입니다.)
1 FileName    db "MYTASK  IMG" 
view plain | print | copy to clipboard | ?

 이젠, 모든 것이 준비된 디스켙을 가지고 부팅만 하시면 됩니다. 자주 수정하고, 부팅하고 또
에러를 확인한 후 다시 부팅하는 과정이 너무 버겁습니다. 그럴땐 VMware®Bochs등을
사용하시면 편할 겁니다.
(저의 경우엔 Bochs보단 VMware®가 좀더 잘 동작하는 것 같았습니다.)
 

 


이제 몰하나?

^^; 이제 몰 하다니요. 이젠 자신만의 커널 알고리즘을 개발하여 운영체제를 만드셔야죠.
(ㅋ...) 즉, ucos-ii.obj파일을 제거하고 기타 Task관련 소스들을 제거하거나 수정해서
자신만의 운영체제를 만드는 겁니다. 물론, 기존 커널을 그대로 이용하셔도 상관없습니다.
자신만의 UI를 개발하여 포팅하고, 좀 더 나아가서 파일 시스템, 네트웍 그리고
사운드 관련 드라이버도 작성해 보는 등 갈길이 멀답니다.
이글로 인해 그 모든 절차나 길을 조금이라도 보았으면 하는 바람입니다.
건투를 빕니다!

2003.09.02 이건우

 ::TOP



기타 질문&답변 : [ PROJECT -> 질문&답변 게시판 ] 참고 자료 : - 디스크 부팅 이미지 만들기 가이드 - PC 보호모드로 포팅된 uCOS-II 에 인터럽트 추가 예제 참고 사이트 : - 오재준님이 작성하신 Bellona 운영체제 사이트입니다. http://www.bellona2.com/ - 기타 관련사이트는 PROJECT -> OS PAGE에 연결된 링크를 참조하시기 바랍니다.

출처 :
신고
크리에이티브 커먼즈 라이선스
Creative Commons License
TAG ucos
 

Porting uC/OS-II to the x86 Protected Mode

Copyright (C) 2001-2006, Jean Louis Gareau. All rights reserved.
The material presented below is for educational purposes only.
To use this material for commercial purposes, please contact the author at jeangareau@yahoo.com.

This page describes the port of mC/OS-II to a protected mode, 32-bit, flat memory model of the 80386, 80486, Pentium and Pentium II CPUs.

mC/OS-II is a portable, ROMable, preemptive, real-time, multitasking kernel for microprocessors. Originally written in C and x86 (real mode) assembly languages, it has been ported to a variety of microprocessors. For more details about mC/OS-II, see the Reference section or visit www.micrium.com.

This port requires the following development tools:

  • Microsoft Macro Assembler?6.11 (MASM). Note: any other version (including 6.11d) may not work.
  • Microsoft Visual C++?6.0 (VC++).

DOWNLOAD

The port (ucosx86p.zip) can be downloaded for free, as long as it is not being used commercially.

PORT

The port is loosely based on a mix of the small & large memory models provided on the standard mC/OS-II distribution. The major differences are highlighted below:

  Large memory model implementation Protected mode implementation
Registers 32-bit real mode pointers (i.e. 16-bit segment registers and 16-bit offsets) 32-bit protected mode registers (i.e. no segment register, 32-bit offsets)
Initialization MS-DOS based. The system actually runs as an MS-DOS application and occasionally makes BIOS calls. Full autonomy. No Ms-DOS nor BIOS dependencies.
Clock Partially relies on MS-DOS clock handler Full implementation

The X86 ports provided on the standard mC/OS-II distribution have some real mode dependencies:

  • mC/OS-II is loaded and runs as a real-mode DOS application.
  • The underlying system is already initialized and is in a known state (thanks to DOS).
  • The implementation calls the default DOS clock interrupt handler upon completing its internal handling of that interrupt.

These assumptions do not hold in protected mode since DOS only runs in real mode. Consequently the following steps, described in the following sections, are required to complete the port:

Steps Description
Loading the application The application cannot be loaded by DOS (since there is no DOS) and requires its own loader.
Initializing the hardware The hardware must be initialized and brought to a known and stable state. Interrupts – particularly the clock interrupt – must be fully processed.
Converting to a 32-bit, flat memory model. Converting 16-bit, real mode code to 32-bit, flat code.
Building the application Compiling, linking and preparing a bootable disk.

Let’s recall that uC/OS is implemented as a library, or a set of function calls, bundled with the target application. These steps are consequently application-centered.

Loading the Application

The application can be loaded in various ways:

  1. It can be loaded from DOS. But switching into protected mode and fully bypassing DOS and the BIOS may create some inconsistencies inside DOS, preventing a normal return to it. Thus, the PC would have to be rebooted in order to get back to DOS. Also, the application would have to be built as a DOS application, requiring a 16-bit compiler.
  2. It can be loaded from a floppy disk upon boot-up. By providing a bootstrap loader, the application would be the first thing loaded and would be in full control. The PC also has to be rebooted back to DOS (or Windows) if required.
  3. It can be burned into PROM, into a stand-alone system.

Since I did not have a 16-bit compiler (I am using Microsoft Visual C++ 6.0) and I already had a bootstrap loader at hand, I decided to choose method #2. I also used a second PC to test the application, in order not to have to reboot my workstation after each test.

The bootstrap loader (BootSctr.img) can easily be installed on the very first sector of a floppy disk (e.g. the boot sector) by using the DEBUG program, distributed with DOS and Windows. The DEBUG’s write command has the following format:

-w offset disk track sector_count

By executing the following commands:

C:\MyTask>debug bootstrap.img

-w 0100 0 0 1

-q

DEBUG loads the file in memory at offset 0100h (the segment address is irrelevant) and copies 512 bytes from offset 100h (where the file is) onto drive A, on track 0, for 1 sector (512 bytes).

When loaded, this bootstrap loader:

  1. Loads the first 64k of the floppy disk (the first file in fact) at the physical address 1000h (we will see why this address is important later).
  2. Disables the interrupts.
  3. Jumps at 1000h to start executing the application.
Initializing the Hardware

mC/OS-II is normally initialized within the application, by calling OsInit(). This assumes that the application has already been loaded and started. But in the current case, the protected mode must first be activated in order to start the application in a 32-bit, flat memory model mode. Thus, a special application entry point is required, which must be run before main(). Such an entry point is normally provided with a compiler and is operating system-dependent. In our case, since there is no underlying operating system, the entry point must perform itself any initialization tasks required to run the application. Luckily, there are only a few things to care about.

The entry point of the application is coded in Entry.asm. With the interrupts still disabled, the following actions are performed:

  • The protected mode is activated with a flat memory model that spans 4GB of physical memory.
  • All segment registers are initialized to default values in order to "forget" about them (hence obtaining a flat, non-segmented memory model).
  • A temporary 32-bit stack is set to address 8000h (an arbitrary address).
  • A call is done to main(), which is the application’s entry point.
  • In case main() returns, an infinite loop is executed. This is not really required, since main() is not expected to return.

The file also contains the system tables required by the processor in protected mode:

  • Global Descriptor Table (GDT). Since all tasks are given full privileges (CPL 0) and share the same address space (e.g. the entire physical memory), only one code and data descriptors are required.
Entry Description
00h Unused (set to 0)
08h Code segment, with the following attributes:
  • code segment
  • executable
  • read-only
  • base address of 0
  • limit of 4GB (FFFFFh, with the G bit set)
  • D-bit set (to run 32-bit code by default)
10h Data and Stack segment, with the following attributes:
  • data segment
  • writable
  • base address of 0
  • limit of 4GB (FFFFFh, with the G bit set)
  • B-bit set (to execute 32-bit stack instructions by default)
  • Interrupt Descriptor Table (IDT). Only 64 entries are reserved, among them 16 for mC/OS-II and the application (the number can be increased as needed).
Entry Description
00h-1Fh CPU interrupts and exceptions
20h-2Fh Hardware Interrupt Request Lines (IRQs)
30h-3F Available for mC/OS and the application
40h-FFh Unused
  • There is no Local Descriptor Table (LDT) in use.

The rest of the hardware initialization is performed in the application. Once in main(), a call is done to OsCpuInit(), in os_cpu_c.c, in order to perform the following:

  • Enable the address line 20, normally disabled for some real mode considerations. The line is enabled by sending a few commands to the Intel 8042 keyboard controller. See InitA20() for details (os_cpu_c.c)
  • Relocate the IRQ interrupts, since the overlap the CPU interrupts and exceptions (for instance, it is not possible to know if the interrupt 0 has been triggered by the clock or a division by zero). The IRQ are relocated in the range 20h-2Fh by sending a few commands to the Intel 8259 interrupt controllers. See InitPIC() for details (os_cpu_c.c)
  • The interrupt table is initialized by using SetIntVector() and SetIDTGate(). The 64 entries are set to point to a default interrupt handler (DefIntHandler(), in os_cpu_a.asm), which simply performs an interrupt return
  • The General Protection Fault (interrupt 13h), triggered by the CPU when a fault is detected (assigning invalid values to segment registers, executing an interrupt above 40h, etc.), is assigned a dump stack handler (DumpStackHandler(), in os_cpu_a.asm). This handler displays the address of the faulty instruction on the upper-left corner of the screen and enters an infinite loop. This is useful to identify the source of a problem.
  • The clock handler (OsTickISR(), in os_cpu_a.asm) is installed as the interrupt 20h handler.
  • The mC/OS-II context switch handler (OSCtxSw(), in os_cpu_a.asm), is installed as the interrupt uCOS handler (uCOS is defined as 0x30 in os_cpu.h).

Back in main(), OsInit() is then called to initialize mC/OS. Two tasks are then created by calling OsTaskCreate() twice. Finally, multi-tasking is started by executing OSStart(), which never returns.

Note that the entire initialization takes place with the interrupts disabled; they are re-enabled when the first task is executed.

Converting to a 32-Bit, Flat Memory Model
  • A few typedefs and definitions are added in os_cpu.h:   
    • The format of an interrupt gate (IDT_GATE)
    • Interrupt gate types (IDTGATE_xxx)
    • The default code selector (CS_SELECTOR), required to initialize the interrupt gates
  • OSTaskStkInit() (in os_cpu_c.c) is updated to take into account:
    • The return address (which is TaskBucket()), should a task returns from its main function
    • The initial flag register. Note that the IF bit (interrupt enabled) must be set, otherwise interrupts will be disabled for that task
    • The code selector, which is always 08h (the second GDT entry)
    • 32-bit offset registers.
  • Converting the 16-bit real mode assembly functions (OSTickISR(), OSStartHighRdy(), OSCtxSw(),OSIntCtxSw(), all in os_cpu_a.asm), which consist of:
    • Removing segment registers
    • Using 32-bit offset registers (EAX instead of AX for instance)
    • Using 32-bit instructions (iretd instead of iret, for instance)
  • OSTickISR() (Ix86p_a.asm) makes no longer a call to the previous clock interrupt handler, but it sends an end-of-interrupt to the interrupt controllers (i8259). This would also be required for each hardware interrupt (IRQ) handler.
  • Some C library functions are added: inportb() and outportb(), implemented in assembly.

Additionally, minor changes have been done in the include files:

  • In os_cfg.h, the maximum number of tasks (OS_MAX_TASKS) is defined as 2 and the mC/OS interrupt (uCOS) is defined as 0x30.
Building the Application

The installation procedure is straight-forward:

  1. Load and unzip ucosx86p.zip. The distribution is as follows:
Subdirectory File Description
Bin\    
  BootSctr.img As already described.
  ExeToImg.exe As already described.
  Ucos-ii.obj The object file of mC/OS-II. The source of it is available from the book.
Entry\    
  Entry.asm The entry point, in assembly. This is where the protected mode is enabled, and is very similar to Example 2.
  Entry.lst The assembled listing of Entry.asm.
  Entry.obj The assembled application entry point.
  Makefile The Makefile to build Entry.obj.
MyTask\    
  MyTask.dsw The Visual C++ (VC++) project file.
  MyTask.c Source file of the test application.
  Includes.h Os_cfg.h Ucos.h mC/OS-II and application header files.
  os_cpu_c.c os_cpu.h os_cpu_a.asm The 80x86 protected mode port of mC/OS-II
  Build.bat As described earlier.
  Debug.txt As described earlier.
  1. Build the project using Visual C++:
  • Go to the Dev sub-directory.
  • Double-click on the MyTask.dsw file to open the project in Visual C++ 6.0
  • Press F7 to build the application. The final image will be in Release\MyTask.img
  • Insert a formatted 1.44MB floppy disk in your drive A:
  • Double-click on (or execute) the file Build.bat to build a bootable floppy disk
  • Reboot with the diskette in drive A: in place, or transfer the diskette to another machine and reboot that machine

WHAT'S NEXT?

The next step would be to add paging to mC/OS-II. This step is significant since it will require many changes in the operating system itself. The objective is to have the ability to run separate tasks in their own address space, which could normally span 4GB on a x86. Paging also offers other advantages, such as isolating the kernel from faulty tasks, shared code and data, etc. Best of all, this port will be available on the 386 and up.

REFERENCE

  1. Labrosse, Jean J., "MicroC/OS-II The Real-Time Kernel", R&D Publications, 2002

Micrium, mC/OS-II are trademarks of Jean J. Labrosse.

출처 : http://www.ucos-ii.com/intel

신고
크리에이티브 커먼즈 라이선스
Creative Commons License
1 

카테고리

분류 전체보기 (107)
::::::Dairy::::: (5)
:::::what?::::: (1)
:::::Computer::::: (5)
:::::Idea::::: (2)
:::::Want::::: (1)

달력

«   2007/03   »
        1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31

티스토리 툴바