NASM-IDE与x86编程教程：从入门到实战

需积分: 9 171 浏览量更新于2024-07-26 收藏 4.23MB PDF 举报

《Assembly Language Step-by-Step Programming: Programming with DOS and Linux, Second Edition》是由Jeff Duntemann所著的一本深入浅出的书籍，专注于16位汇编语言编程的概念和技术。该书针对初学者和进阶者，以DOS和Linux环境为基础，提供了一个学习和实践汇编语言编程的实用指南。在第一部分，作者回顾了历史，提到了之前版本中的简单编辑器JED，但强调JED已不再适用，取而代之的是NASM-IDE，这是由Robert Anderton为NASM创建的一款工具。NASM-IDE专为DOS设计，对Linux用户而言可能不够支持，不过在Linux环境下，作者推荐学习并使用如EMACS这样的文本编辑器，因为人们在学习Linux的过程中往往会对它们产生深厚的感情。第二章介绍了二进制和十六进制的基础概念，这对于理解计算机如何处理数据至关重要。接着，第三章深入探讨了计算机硬件层面，揭示了计算机内部工作原理。第四章则引导读者进入汇编语言的世界，讲述如何创建自己的程序，包括理解程序编译过程。第五章特别介绍了NASM-IDE，一个用于编写和调试程序的集成开发环境（IDE），它强调了持续学习和实践的重要性。第六章讲解x86处理器及其分段内存系统，这对于理解指令集和内存管理至关重要。第七章聚焦于机器指令，让读者亲身体验指令的执行过程。第八章关注实际应用，即如何编写能够正常工作的程序，这涉及模块化编程和程序结构的设计。第九章进一步提升技能，通过介绍子程序和宏来实现代码复用和简化复杂任务。《Assembly Language Step-by-Step Programming》是一本实用的教程，适合那些希望深入了解汇编语言、探索底层计算机工作原理，并在DOS和Linux环境中进行程序开发的读者。无论你是初学者还是希望巩固基础的开发者，这本书都提供了丰富的理论知识和实践经验，帮助你逐步掌握这一古老且强大的编程技术。

or 20 years ago. The column marked "PROGRAM INSTRUCTIONS" is the main path around the edge

of the board, of which only a portion can be shown here. This is the assembly language computer

program, the actual series of steps and tests that, when executed, causes the computer to do

something useful. Setting up this series of program instructions is what programming in assembly

language actually is.

Everything else is odds and ends in the middle of the board that serve the game in progress. You're

probably noticing (perhaps with sagging spirits) that there are a lot of numbers involved. (They're weird

numbers, too-what, for example, does "004B" mean? I deal with that issue in Chapter 2, Alien Bases.)

I'm sorry, but that's simply the way the game is played. Assembly language, at the innermost level, is

nothing but numbers, and if you hate numbers the way most people hate anchovies, you're going to

have a rough time of it. (I like anchovies, which is part of my legend. Learn to like numbers. They're not

as salty.)

I should caution you that the Game of Assembly Language represents no real computer processor like

the Pentium. Also, I've made the names of instructions more clearly understandable than the names of

the instructions in Intel assembly language. In the real world, instruction names are typically things like

STOSB, DAA, INC, SBB, and other crypticisms that cannot be understood without considerable

explanation. We're easing into this stuff sidewise, and in this chapter I have to sugarcoat certain things

a little to draw the metaphors clearly.

Code and Data

Like most board games (including the Game of Big Bux), the assembly language board game consists

of two broad categories of elements: game steps and places to store things. The "game steps" are the

steps and tests I've been speaking of all along. The places to store things are just that: cubbyholes into

which you can place numbers, with the confidence that those numbers will remain where you put them

until you take them out or change them somehow.

In programming terms, the game steps are called code, and the numbers in their cubbyholes (as

distinct from the cubbyholes themselves) are called data. The cubbyholes themselves are usually

called storage. (The difference between the places you store information and the information you store

in them is crucial. Don't confuse them.)

The Game of Big Bux works the same way. Look back to Figure 1.1 and note that in the Start a

Business detour, there is an instruction reading Add $850,000 to checking account. The checking

account is one of several different kinds of storage in the Game of Big Bux, and money values are a

type of data. It's no different conceptually from an instruction in the Game of Assembly Language

reading ADD 5 to Register A. An ADD instruction in the code alters a data value stored in a cubbyhole

named Register A.

Code and data are two very different kinds of critters, but they interact in ways that make the game

interesting. The code includes steps that place data into storage (MOVE instructions) and steps that

alter data that is already in storage (INCREMENT and DECREMENT instructions). Most of the time

you'll think of code as being the master of data, in that the code writes data values into storage. Data

does influence code as well, however. Among the tests that the code makes are tests that examine

data in storage, the COMPARE instructions. If a given data value exists in storage, the code may do

one thing; if that value does not exist in storage, the code will do something else, as in the JUMP

BACK and JUMP AHEAD instructions.

The short block of instructions marked PROCEDURE is a detour off the main stream of instructions. At

any point in the program you can duck out into the procedure, perform its steps and tests, and then

return to the very place from which you left. This allows a sequence of steps and tests that is generally

useful and used frequently to exist in only one place rather than exist as a separate copy everywhere it

is needed.

Addresses

Another critical concept lies in the funny numbers at the left side of the program step locations and data

locations. Each number is unique, in that a location tagged with that number appears only once inside

the computer. This location is called an address. Data is stored and retrieved by specifying the data's

address in the machine. Procedures are called by specifying the address at which they begin.

The little box (which is also a storage location) marked PROGRAM COUNTER keeps the address of

the next instruction to be performed. The number inside the program counter is increased by one (we

say, "incremented") each time an instruction is performed unless the instructions tells the program

counter to do something else. For example: Notice the JUMP BACK 7 instruction at address 0049.

When this instruction is performed, the program counter will "back up" by seven counts. This is

analogous to the "go back three spaces" concept in most board games.

Metaphor Check!

That's about as much explanation of the Game of Assembly Language as I'm going to offer for now.

This is still Chapter 1, and we're still in metaphor territory. People who have had some exposure to

computers will recognize and understand more of what Figure 1.2 is doing. (There's a real, traceable

program going on in there-I dare you to figure out what it does-and how!) People with no exposure to

computer innards at all shouldn't feel left behind for being utterly lost. I created the Game of Assembly

Language solely to put across the following points:

The individual steps are very simple. One single instruction rarely does more than move a single

byte from one storage cubbyhole to another, or compare the value contained in one storage

cubbyhole to a value contained in another. This is good news, because it allows you to concentrate

on the simple task accomplished by a single instruction without being overwhelmed by complexity.

The bad news, however, is the following.

It takes a lot of steps to do anything useful. You can often write a useful program in such

languages as Pascal or BASIC in five or six lines. You can actually create useful programs in

Visual Basic and Delphi without writing any code at all. (The code is still there…but the code is

"canned" and all you're really doing is choosing which chunks of canned code in a collection of

many such chunks will run.) A useful assembly language program cannot be implemented in fewer

than about 50 lines, and anything challenging takes hundreds or thousands of lines. The skill of

assembly language programming lies in structuring these hundreds or thousands of instructions so

that the program can be read and understood.

The key to assembly language is understanding memory addresses. In such languages as Pascal

and BASIC, the compiler takes care of where something is located-you simply have to give that

something a name, and call it by that name whenever you want to look at it or change it. In

assembly language, you must always be cognizant of where things are in your computer's memory.

So, in working through this book, pay special attention to the concept of addressing, which is

nothing more than the art of specifying where something is. The Game of Assembly Language is

peppered with addresses and instructions that work with addresses (such as MOVE data at B to

C, which means move the data stored at the address specified by register B to the address

specified by register C). Addressing is by far the trickiest part of assembly language, but master it

and you've got the whole thing in your hip pocket.

Everything I've said so far has been orientation. I've tried to give you a taste of the big picture of

assembly language and how its fundamental principles relate to the life you've been living all along. Life

is a sequence of steps and tests, and so are board games-and so is assembly language. Keep those

metaphors in mind as we proceed to get real by confronting the nature of computer numbers.

Chapter 2: Alien Bases Getting Your Arms around

Binary and Hexadecimal

The Return of the New Math Monster

The year 1966. Perhaps you were there. New Math burst upon the grade school curricula of the nation,

and homework became a turmoil of number lines, sets, and alternate bases. Middle-class parents

scratched their heads with their children over questions like, "What is 17 in Base Five?" and "Which

sets does the Null Set belong to?" In very short order (I recall a period of about two months), the whole

thing was tossed in the trash as quickly as it had been concocted by addle-brained educrats with too

little to do.

This was a pity, actually. What nobody seemed to realize at the time was that, granted, we were

learning New Math—except that Old Math had never been taught at the grade school level either. We

kept wondering of what possible use it was to know what the intersection of the set of squirrels and the

set of mammals was. The truth, of course, was that it was no use at all. Mathematics in America has

always been taught as applied mathematics—arithmetic—heavy on the word problems. If it won't help

you balance your checkbook or proportion a recipe, it ain't real math, man. Little or nothing of the logic

of mathematics has ever made it into the elementary classroom, in part because elementary school in

America has historically been a sort of trade school for everyday life. Getting the little beasts

fundamentally literate is difficult enough. Trying to get them to appreciate the beauty of alternate

number systems simply went over the line for practical middle-class America.

I was one of the few who enjoyed fussing with math in the New-Age style back in 1966, but I gladly laid

it aside when the whole thing blew over. I didn't have to pick it up again until 1976, when, after working

like a maniac with a wire-wrap gun for several weeks, I fed power to my COSMAC ELF computer and

was greeted by an LED display of a pair of numbers in base 16!

Mon dieu, New Math redux…

This chapter exists because at the assembly language level, your computer does not understand

numbers in our familiar base 10. Computers, in a slightly schizoid fashion, work in base 2 and base

16—all at the same time. If you're willing to confine yourself to higher-level languages such as Basic or

Pascal, you can ignore these alien bases altogether, or perhaps treat them as an advanced topic once

you get the rest of the language down pat. Not here. Everything in assembly language depends on your

thorough understanding of these two number bases. So before we do anything else, we're going to

learn how to count all over again—in Martian.

Counting in Martian

There is intelligent life on Mars.

That is, the Martians are intelligent enough to know from watching our TV programs these past 50

years that a thriving tourist industry would not be to their advantage. So they've remained in hiding,

emerging only briefly to carve big rocks into the shape of Elvis's face to help the National Enquirer

ensure that no one will ever take Mars seriously again. The Martians do occasionally communicate with

science fiction writers like me, knowing full well that nobody has ever taken us seriously. Hence the

information in this section, which involves the way Martians count.

Martians have three fingers on one hand, and only one finger on the other. Male Martians have their

three fingers on the left hand, while females have their three fingers on the right hand. This makes

waltzing and certain other things easier.

Like human beings and any other intelligent race, Martians started counting by using their fingers. Just

as we used our 10 fingers to set things off in groups and powers of 10, the Martians used their four

fingers to set things off in groups and powers of four. Over time, our civilization standardized on a set of

10 digits to serve our number system. The Martians, similarly, standardized on a set of four digits for

their number system. The four digits follow, along with the names of the digits as the Martians

pronounce them: T (xip), (foo), n (bar), = (bas).

Like our zero, xip is a placeholder representing no items, and while Martians sometimes count from xip,

they usually start with foo, representing a single item. So they start counting: Foo, bar, bas…

Now what? What comes after bas? Table 2.1 demonstrates how the Martians count to what we would

call 25.

Table 2.1: Counting in Martian, Base Fooby

MARTIAN NUMERALS MARTIAN PRONUNCIATION EARTH EQUIVALENT

T Xip 0

Foo 1

n Bar 2

= Bas 3

Fooby 4

Fooby-foo 5

Fooby-bar 6

Fooby-bas 7

nT Barby 8

Barby-foo 9

nn Barby-bar 10

n= Barby-bas 11

=T Basby 12

Basby-foo 13

=n Basby-bar 14

== Basby-bas 15

Foobity 16

Foobity-foo 17

剩余476页未读，继续阅读

moosa

粉丝: 1
资源: 1

NASM-IDE与x86编程教程：从入门到实战

Assembly Language Step-by-Step Programming with DOS and Linux, 2nd Edition 英文版 (chm)

Assembly Language Step-By-Step - (Wiley, 2009, 0470497025).pdf

汇编语言基于Linux环境Assembly Language Step-by-Step - Programming with Linux

一步一步学习linux汇编语言程序设计（Assembly Language Step-by-Step-Programming with Linux）第三版（最新版））

《Assembly Language Step-by-Step: Programming with Linux® Third Edition》简介

Assembly.Language.Step-by-Step.-.Programming.with.Linux,.3rd.Edition.Oct.2009

Assembly.Language.Step-by-Step.Programming.with.DOS.and.Linux.Second.Edition

Assembly.Language.Step-by-Step.Programming.with.DOS.and.Linux.Second.Edition.part3

Assembly.Language.Step-by-Step.Programming.with.DOS.and.Linux.Second.Edition.part2

Assembly.Language.Step-by-Step.Programming.with.DOS.and.Linux.Second.Edition.Part1

最新资源