How can I find information on extremely low level programming?

Question

First, some background on this question: Today, I was looking for an explanation of how test works in assembly. Unfortunately, I can't seem to find an answer in google, because "test", "assembly", etc. are all common words that are too often used in other cases. Eventually I found some information by searching for "conditional branch", which isn't quite what I'm looking for, but is a good enough starting place.

My question for you is, where do I go for information on low level computer operations? e.g. if I want to find out how a branch statement works, or how the cpu cache functions, or what happens to the extra bit when you shift a register? How do I search for these?

Answer 1

Find about microprogramming, or if that's not enough, there is nano programming. There was a nano programmed computer some decades back (a classic) but I can't remember the name.

For microprogramming, you might like to play with this. It's a microprogrammable processor architecture simulator, and there are some example architectures to download too.

Answer 2

Assembly instructions are architecture specific, so you will find their exact behaviour defined in the documentation for that architecture. If you are just learning, I suggest you start with a simple RISC architecture, like the one used by Atmel 8 bit avr chips.

"Lower" than assembly instructions are "opcodes" (Operation Codes) which are what assembly instructions are "assembled" into (amongs few other things done by modern assemblers). These are highly specific to the architecture, and have to do with the way the cpu will treat the argument(s) (if any) of the instruction, for example, the argument may be an offset from the current addresss (relative) or it may be a full address anywhere in memory or it may be a literal value or something else entirely. Since at some point, we need to boil down the instruction into the specific version where our arguments are treated as we want, instructions which take arguments will exists in different "versions" depending on the kind of arguments they can take (which modes of "addressing"). One example of an instruction which exist in several versions (supports several addressing modes) is the LDA in the beloved 6502. ( http://www.6502.org/tutorials/6502opcodes.html#LDA ). So basically, the lower level than assembly would be to simply write opcodes into memory, this is totally doable and will probably get you quite intimate with your chosen chip.

It is widely different which addressing modes are supported by which instructions in which architectures.

If you want "lower" level than that (ie, how the actual machine code is executed on the gates of the chip) you would need to research a chip which is well-documented and reverse engineered, something like http://visual6502.org/ may be of help.

On the topic of 6502, as Olivier Dulac mentions, skilldricks easy6502 project is also very helpful in learning and understanding (6502) assembly programming, addressing modes and opcodes. http://skilldrick.github.io/easy6502/

Note that getting started with x86, which is a CISC architecture can be quite daunting for beginners and even for RISC programmers.

Answer 3

This is what I understand as "very low level programming": http://www.cs.usfca.edu/~cruse/cs630f06/

With the material from this curse, and the Intel manual, I've been able to do some funny things, such as waking up all the cores in a multicore processor and assign code to execute to each of them, from MS-DOS.

Something even lower than this would be to design your own microprocessor using VHDL or Verilog. Then you are no longer "programming", but describing electronics, although the way yo do it seems like programming. In fact, you will end up with a somewhat different paradigm, in which statements, by nature, execute in parallel instead of sequentially. This way, interchanging the value of two variables is done as this:

a <= b;
b <= a;

Instead of this (the way all we know):

t = a;
a = b;
b = t;

For examples on describing processors and electronics, go to http://www.opencores.org