x86 Assembly Wikibook

Link To Content
 
This book covers assembly language programming for the x86 family of microprocessors. The objective is to teach how to program in x86 assembly, as well as the history and basic architecture of x86 processor family,. 

When referring to x86 we address the complete range of x86-based processors but keep in mind that x86-32 Assembly is commonly referred to as IA-32 (Intel Architecture, 32-bit) Assembly, a 32-bit extension of the original Intel x86 processor architecture. IA-32 has full backwards compatibility (16-bit). AMD64 or AMD 64-bit extension is called x86-64 and is backwards compatible with 32-bit code without performance loss. Intel 64 previously named IA-32e or EM64T is almost identical to x86-64. Throughout the book these terms may be used interchangeably when appropriate. A special notice will be given if covering 16-bit, 32-bit or 64-bits architectures and on any limitations so to limit confusion.     

Win32 Programming for x86 Assembly Language Programmers

 Link To Content
Contents: 

The very beginnings 
1 Introduction to Console Applications and Files 
2 A Basic Win32 GUI Program--WINBASIC.ASM 
3 Translating Win32 Documentation 
Some fundamentals 
4 Popup Windows and Ownership 
5 Child Windows 
6 A Little More on Messages and an Introduction to the Mouse 
7 Introduction to Graphics 
8 Refreshing with WM_PAINT 
9 Introduction to Controls 
Message loops 
10 Conventional and Thread Message Loops 
11 Greedy Message Loop 
GUI topics 
12 BUTTON 
12 Introduction to Menus 
12 Introduction to Dialogs 
Non-GUI topics 
13 Window Styles 
14 Deadlock Theory 
15 More Programming Information 
15 The Rest of Windows  

The Art of Assembly Languange

Link To Content
The Art of Assembly Language Programming is the World's #1 book on x86 assembly language programming! Thousands upon thousands of programmers have learned assembly language programming using The Art of Assembly Language. You, too, will learn this powerful programming language easier than ever before possible using The Art of Assembly Language Programming (AoA). 

No single textbook can be all things to all people. This text is no exception. I've geared this text and the accompanying software to University level students who've never previously learned assembly language programming. This is not to say that others cannot benefit from this work; it simply means that as I've had to make choices about the presentation, I've made choices that should prove most comfortable for this audience I've chosen. 

A secondary audience who could benefit from this presentation is any motivated person that really wants to learn assembly language. Although I assume a certain level of mathematical maturity from the reader (i.e., high school algebra), most of the "tough math" in this textbook is incidental to learning assembly language programming and you can easily skip over it without fear that you'll miss too much. High school students and those who haven't seen a school in 40 years have effectively used this text (and its DOS counterpart) to learn assembly language programming. 

The organization of this text reflects the diverse audience for which it is intended. For example, in a standard textbook each chapter typically has its own set of questions, programming exercises, and laboratory exercises. Since the primary audience for this text is University students, such pedagogical material does appear within this text. However, recognizing that not everyone who reads this text wants to bother with this material (e.g., downloading it), this text moves such pedagogical material to the end of each volume in the text and places this material in a separate chapter. This is somewhat of an unusual organization, but I feel that University instructors can easily adapt to this organization and it saves burdening those who aren't interested in this material. 

One audience to whom this book is specifically not directed are those persons who are already comfortable programming in 80x86 assembly language. Undoubtedly, there is a lot of material such programmers will find of use in this textbook. However, my experience suggests that those who've already learned x86 assembly language with an assembler like MASM, TASM, or NASM rebel at the thought of having to relearn basic assembly language syntax (as they would to have to learn HLA). If you fall into this category, I humbly apologize for not writing a text more to your liking. However, my goal has always been to teach those who don't already know assembly language, not extend the education of those who do. If you happen to fall into this category and you don't particularly like this text's presentation, there is some good news: there are dozens of texts on assembly language programming that use MASM and TASM out there. So you don't really need this one. 

The first thing any instructor will notice when reviewing this text is that it's far too large for any reasonable course. That's because assembly language courses generally come in two flavors: a machine organization course (more hardware oriented) and an assembly language programming course (more software oriented). No text that is "just the right size" is suitable for both types of classes. Combining the information for both courses, plus advanced information students may need after they finish the course, produces a large text, like this one. 

If you're an instructor with a limited schedule for teaching this subject, you'll have to carefully select the material you choose to present over the time span of your course. To help, I've included some brief notes at the beginning of each Volume in this text that suggests whether a chapter in that Volume is appropriate for a machine organization course, an assembly language programming course, or an advanced assembly programming course. These brief course notes can help you choose which chapters you want to cover in your course. 

If you would like to offer hard copies of this text in the bookstore for your students, I will attempt to arrange with some "Custom Textbook Publishing" houses to make this material available on an "as-requested" basis. As I work out arrangements with such outfits, I'll post ordering information on Webster ( http://webster.cs.ucr.edu ). If your school has a printing and reprographics department, or you have a local business that handles custom publishing, you can certainly request copyright clearance to print the text locally. 

If you're not taking a formal course, just keep in mind that you don't have to read this text straight through, chapter by chapter. If you want to learn assembly language programming and some of the machine organization chapters seem a little too hardware oriented for your tastes, feel free to skip those chapters and come back to them later on, when you understand the need to learn this information.  

Programmed Introduction to MIPS Assembly Languange

Link To Content

This is a course in assembly language programming of the MIPS processor. It emphasizes the topics needed for study of computer architecture: bits, bit patterns, operations on bit patterns, and how bit patterns represent instructions and data. This course is equivalent to a semester-long junior college or university course (except, perhaps, for the emphasis on bit patterns). 

The emphasis of the course is on understanding how computers work. This will provide a basis for further study of computer architecture and computer software. The MIPS processor, the subject of this course, has a well designed architecture and is particularly fruitful to study. However, the goal of the course is not to turn you into a MIPS programmer, but to give you an understanding of all computer systems. 

The only equipment you need for this course is a PC. The only software you need is the SPIM simulator of the MIPS32 processor and a text editor. The simulator is available by free download (see appendix A). Example programs are presented using an MS Windows operating system. However, you can use any platform that runs SPIM. (There are many). 

Assembly Language is normally taken the semester after a course in a high level programming language (such as Java or C). This course assumes that you have this background although no specific programming language is required. 

Read the pages of this course actively. Think about and answer the question at the bottom of each page. (This style of tutorial is called programmed learning. It is very effective for technical material). Most questions call for just a little thought. Some call for pencil and paper. Keep a pencil and a scrap of paper next to your keyboard. Each chapter is about 15 pages long. Spend several minutes per page. You can read each chapter in about 30 minutes. However, for maximum benefit, you should run some of the example programs, write some programs of your own, and then think about your results. This may take several hours.  

PC Assembly Language

Link To Content
The tutorial has extensive coverage of interfacing assembly and C code and so might be of interest to C programmers who want to learn about how C works under the hood. All the examples use the free NASM (Netwide) assembler. The tutorial only covers programming under 32-bit protected mode and requires a 32-bit protected mode compiler. 
I have example code files for: DJGPP, Borland, Microsoft, Open Watcom and Linux C compilers. The examples in the text of the tutorial are for DJGPP only, but how to interface with the other compilers is discussed as well. The example files also include macros that allow easy input/output and debugging (register dumps, memory dumps, coprocessor dumps and stack dumps). If you plan on running the examples inthe tutorial, you must download the appropriate example code file. It contains support files used by the examples in the tutorial (such as asm_io.inc). 

Table of Contents 

1. Introduction 
2. Basic Assembly Language 
3. Bit Operations 
4. Subprograms 
5. Arrays 
6. Floating Point 
7. Structures and C++ 

The purpose of this book is to give the reader a better understanding of how computers really work at a lower level than in programming languages like Pascal. By gaining a deeper understanding of how computers work, the reader can often be much more productive developing software in higher level languages such as C and C++. Learning to program in assembly language is an excellent way to achieve this goal. Other PC assembly language books still teach how to program the 8086 processor that the original PC used in 
1981! The 8086 processor only supported real mode. In this mode, any program may address any memory or device in the computer. This mode is not suitable for a secure, multitasking operating system. This book instead discusses how to program the 80386 and later processors in protected mode 
(the mode that Windows and Linux runs in). This mode supports the features that modern operating systems expect, such as virtual memory and memory protection. There are several reasons to use protected mode: 

1. It is easier to program in protected mode than in the 8086 real mode that other books use. 
2. All modern PC operating systems run in protected mode. 
3. There is free software available that runs in this mode. 

The lack of textbooks for protected mode PC assembly programming is the main reason that the author wrote this book. 

As alluded to above, this text makes use of Free/Open Source software: namely, the NASM assembler and the DJGPP C/C++ compiler. Both of these are available to download from the Internet. The text also discusses how to use NASM assembly code under the Linux operating system and with Borland’s and Microsoft’s C/C++ compilers under Windows. Examples for all of these platforms can be found on my web site: http://www.drpaulcarter.com/pcasm. You must download the example code if you wish to assemble and run many of the examples in this tutorial. 

Be aware that this text does not attempt to cover every aspect of assembly programming. The author has tried to cover the most important topics that all programmers should be acquainted with.  

Beginners Introduction to the Assembly Language of ATMEL-AVR-Microprocessors

 Link To Content
Why learning Assembler? 
Assembler or other languages, that is the question. Why should I learn another language, if I already learned other programming languages? The best argument: while you live in France you are able to get through by speaking English, but you will never feel at home then, and life remains complicated. You can get through with this, but it is rather inappropriate. If things need a hurry, you should use the country's language. 

Short and easy 
Assembler commands translate one by one to executed machine commands. The processor needs only to execute what you want it to do and what is necessary to perform the task. No extra loops and unnecessary features blow up the generated code. If your program storage is short and limited and you have to optimize your program to fit into memory, assembler is choice 1. Shorter programs are easier to debug, every step makes sense. 

Fast and quick 
Because only necessary code steps are executed, assembly programs are as fast as possible. The duration of every step is known. Time critical applications, like time measurements without a hardware timer, that should perform excellent, must be written in assembler. If you have more time and don't mind if your chip remains 99% in a wait state type of operation, you can choose any language you want. 

Assembler is easy to learn 
It is not true that assembly language is more complicated or not as easy to understand than other languages. Learning assembly language for whatever hardware type brings you to understand the basic concepts of any other assembly language dialect. Adding other dialects later is easy. The first assembly code does not look very attractive, with every 100 additional lines programmed it looks better. Perfect programs require some thousand lines of code of exercise, and optimization requires lots of work. As some features are hardware-dependent optimal code requires some familiarity with the hardware concept and the dialect. The first steps are hard in any language. After some weeks of programming you will laugh 
if you go through your first code. Some assembler commands need some months of experience. 

AT90Sxxxx are ideal for learning assembler 
Assembler programs are a little bit silly: the chip executes anything you tell it to do, and does not ask you if you are sure overwriting this and that. All protections must be programmed by you, the chip does anything like it is told. No window warns you, unless you programmed it before. 

Basic design errors are as complicated to debug like in any other computer language. But: testing 
programs on ATMEL chips is very easy. If it does not do what you expect it to do, you can easily add some 
diagnostic lines to the code, reprogram the chip and test it. Bye, bye to you EPROM programmers, to the UV lamps used to erase your test program, to you pins that don't fit into the socket after having them removed some thousand times. 

Changes are now programmed fast, compiled in no time, and either simulated in the studio or checked in circuit. No pin is removed, and no UV lamp gives up just in the moment when you had your excellent idea 
about that bug  

Assemblers And Loaders

Link To Content
Covering the design and implementation of assemblers and loaders, this comprehensive book opens with an introduction to one-pass and two-pass assemblers. Important concepts such as absolute and relocatable object files are discussed, as are assembler features such as local labels and multiple location counters. The format, meaning and implementation of many directives are look at in detail, and the important topics of macros and conditional assembly are introduced. The latter part of the book is concerned with the listing file, the properties of disassemblers and a look at three special types of assemblers. The book closes with a chapter on loaders and includes a very detailed example of the basic operation of a one-pass linking loader, together with other features and concepts such as dynamic loading, bootstrap loaders, and overlays. Lots of (solved) exercises are included throughout, and at the end of each chapter there are review problems and projects. 

This book differs from the typical assembler text in that it is not a programming manual, and it is not concerned with any specific assembler language. Instead it concentrates on the design and implementation of assemblers and loaders. It assumes that the reader has some knowledge of computers and programming, and it aims to explain how assemblers and loaders work. Most of the discussion is general, and most of the examples are in a hypothetical, simple, assembler language. Certain examples are in the assembler languages of actual machines, and those are always specified. Some good references for specific assembler languages are [5, 6, 7, 13, 26, 27, 30, 31, 32, 35, 37, 39, 101]. 

This work has its origins at a point, a few years ago, when my students started complaining about a lack of literature in this field. Since I include assemblers and loaders in classes that I teach every semester, I responded by developing class notes. The notes were an immediate success, and have grown each semester, until I had enough material for an expository paper on the subject. Since I was too busy to polish the paper and submit it, I pretty soon found myself in a situation where the work was too large for a paper. So here it is at last, in the form of a book. 

This is mostly a professional book, intended for computer professionals in general, and especially for systems programmers. However, it can be used as a supplementary text in a systems programming or computer organization class at any level.