Preface
Lance Leventhal wrote a series of books on assembly language programming that many regard as the Assembly Language Programming Bible for their favorite microprocessor.
I theoretically own, somewhere, if the rain hasn't destroyed them yet, a copy of two of his books, the one on the 6809 and the one on the 68000. Thirty years or so ago, I kept trying to use them to help me with a certain project that I have given way too much of my life to, until I realized two things:
The first was that I already understood everything in both of those books, just from studying Motorola's programmers' manuals. Motorola had some really amazing documents at the time. Not perfect, but amazing.
The second was that the approach he had taken was leading me away from my
goals in that project in subtle ways. He wasn't teaching assembly language programming, he was teaching a specific discipline that was being taken up by many in the industry as intellectual meta-infrastructure.
Not incidentally, I was a fan of an internal combustion engine that I read about in Popular Science that a guy named Turner designed, that a friend once looked at and said, "That's a U-joint turned into an engine." I don't remember if it was Turner or the author of the Popular Science article on the engine who called it a rotary V engine -- as in rotary V-8, which makes it sound like a contradiction in terms.
Another friend doubted that the torsional stresses could be properly taken
care of. I asked him about camshafts, and he said, because we've already done that with camshafts.
Maybe I'm a hopeless fan of underdogs.
Turning that engine into a product for ordinary consumers would have required creating a support infrastructure -- mechanics and repair shops trained in subtle technical differences that would not just know how to work on it, but how it works. In addition, there would be parts suppliers, and sales networks and such. But the ordinary internal combustion engine support infrastructure is different, and somehow gets in the way of building support structures for odd-ball engines like that Turner rotary V, and the Wankel engine that Mazda finally gave up on, among many others.
Infrastructure for electric vehicles has been significantly helped by a certain billionaire's involvement. (And rotary engines seem to being brought along, in a comeback as range extenders.)
Established infrastructure gets in the way of many interesting things in our
society.
Somebody famous has said,
The perfect is the enemy of the good.
Many somebodies have parroted this truistic aphorism.
We can logically invert this.
The mediocre good is the enemy of perfection, and therefore the enemy of progress.
Now, mind you, human ideals can never be realized. Ideal is not real. God's ways are not our ways, and his thoughts are not our thoughts (Isaiah 58: 8, 9). But that is not the same thing as saying we should prioritize the mediocre good because perfection is hard to achieve.
Nor is it saying that we can get along without ideals. Ideals are necessary, just not the ultimate end. Ideals keep us from becoming mediocre.
I'm rambling.
What does this side ramble have to do with assembly language primers?
I'm trying to find a step forward on making something real of at least parts of that project that has eaten too much of my life. (Am I a glutton for punishment?)
Some FB friends who like Leventhal's book on the 6809 asked why I said it's not my favorite, and have challenged me to write a better primer.
So I'm thinking maybe such a set of tutorials would be a workable step forward on that project.
That's kind of what I have in mind for this series of blog posts.
But I need to lay out a warning up front that my approach to assembly language is subtly incompatible with most of the existing programming tools. It looks really good until you realize that, if you use my approach, you will sooner or later find yourself trying to, as it were, walk on air, unless you take the time to understand the differences and are willing to develop some of your own tools and share them.
I don't have the means to develop all the missing support tools by myself.
The CPUs aren't quite there, either.
My favorite existing processor, Motorola's 6809, isn't really quite up to my
approach, because it's missing an indexing mode that would allow using the
Load Effective Address instructions to take the address of a variable in the
run-time direct page. We can work around this, but it consumes instructions and processor cycles.
The 68000 isn't quite up to it, either. Not because the 68020 is too complex and the original 68000 doesn't have 32-bit constant offset index modes and it's hard to get Motorola's CPU32 without a lot of SOC stuff that you don't want to mess with initializing, etc. The problem is that the 68000 has all these index registers, but using them as segment registers gets in the way of using them as index registers. LoL. Not really a problem. We can work around this, as well.
Speaking of segment registers, Intel's x86 could have been a bit more workable -- if still clunky, but BP and SP are stuck in the same segment unless you use segment override. And you really don't want to do that because it gets in the way -- BP designed as frame base pointer instead of parameter stack pointer is definitely one of the things we would be fighting against on x86. There are workarounds, such as ignoring that the two stacks are in the same segment. (The Extra Segment doesn't work for this, last time I tried it. That is, you really don't want to be losing access to the parameter stack whenever you want to move strings.) I think I'll let someone else play with that. At least, I'm not interested in doing so again right now. I've seen what happens when that siren song takes its toll.
Existing CPUs that implement the primitives of Forth-like languages or LISP kernels
don't quite do the job either. At least, I have never found one such that
included support for such things as virtualizing address spaces. Real processors are all designed to work within the existing meta-infrastructure.
Motorola's 6800 and 6801 actually get closer than you might expect (ignoring the lack of direct-page opcodes for the unary operators), if you define the use of a few
direct page variables as virtual registers -- software parameter stack
pointer and such -- and define support routines for the virtual registers.
RISC processors can be similarly supported, but need macros instead of routines because of the cost of branches in deeply pipelined architectures.
Of course, that's also true of any processor that doesn't include the necessary registers and operations as part of the native CPU architecture, but it consumes cycles and memory resources. And there is always that siren song of false optimizations that lures you away, into the existing meta-infrastructure.
I keep hearing from people rediscovering "stackless". That's one of those false optimizations. Why it's a false optimization takes a lot of explanation, though. I expect I'll at least partly cover that in the process here.
As we go, I'll demonstrate the necessary virtual registers and support routines for the 6800 and 6801. Once we see what we can do with them and what walls we run into without, we can talk about why and how to apply it other CPUs.
But tutorials need to start simply. Explaining why one needs a parameter stack
while you are teaching how to build a software stack while you are explaining
what LDAA 0,X means gets kind of unwieldy.
And if you are looking for a primer, all this talk of esoteric problems isn't getting you started writing assembly language programs.
Anyway, be warned:
If you proceed with this series, I'm going to teach you things that will make you dissatisfied with the tools you have available, and I don't have the means of creating the missing tools by myself. I hardly have the time to write the tutorial chapters.
So, what does the example I just gave of the 6800/6801 indexed mode load accumulator A
LDAA 0,X
mean? And the 6809 equivalent,
LDA ,X
And the 68000 near-equivalent,
MOVE.B (A0),D0
and the difference between that and, say,
MOVE.L (A0),D0
on the 68000?
Ick. Jumping in too deep already, perhaps. Definitely needs context and underlying concepts. Maybe start with accumulators and data registers.
No comments:
Post a Comment