>Niceguyuk: Fixing unicode chars

2015-05-07T09:30:27Z

Fixing unicode chars

>Wongck at 03:31, 19 February 2012

2012-02-19T03:31:16Z

← Older revision		Revision as of 23:31, 18 February 2012
Line 189:		Line 189:

	Last edited 2002-06-14		Last edited 2002-06-14
			<br/><br/>
			Go back to [[Perihelion tutorial 3]]<br/>
			Proceed to [[Perihelion tutorial 5]]

	[[Category: Perihelions Atari ST M68000 tutorial]]		[[Category: Perihelions Atari ST M68000 tutorial]]

>Wongck at 14:33, 12 October 2011

2011-10-12T14:33:54Z

← Older revision		Revision as of 10:33, 12 October 2011
Line 189:		Line 189:

	Last edited 2002-06-14		Last edited 2002-06-14
	[[Category:~~Category~~ Perihelions Atari ST M68000 tutorial]]
	~~[[Category:Programming]]~~		[[Category: Perihelions Atari ST M68000 tutorial]]
	~~[[Category:Assembly Language~~]]

>Silver Surfer: clean up

2009-05-03T15:37:52Z

clean up

← Older revision		Revision as of 11:37, 3 May 2009
Line 191:		Line 191:
	[[Category:Category Perihelions Atari ST M68000 tutorial]]		[[Category:Category Perihelions Atari ST M68000 tutorial]]
	[[Category:Programming]]		[[Category:Programming]]
			[[Category:Assembly Language]]

>Silver Surfer: clean up

2009-05-03T15:32:15Z

clean up

← Older revision		Revision as of 11:32, 3 May 2009
Line 1:		Line 1:
	~~[[Category:Category Perihelions Atari ST M68000 tutorial]]~~

	'''The Atari ST M68000 tutorial part 4 â€“ of the ways of addressing memory'''		'''The Atari ST M68000 tutorial part 4 â€“ of the ways of addressing memory'''

Line 191:		Line 189:

	Last edited 2002-06-14		Last edited 2002-06-14
			[[Category:Category Perihelions Atari ST M68000 tutorial]]
			[[Category:Programming]]

>Muguk at 10:41, 1 February 2006

2006-02-01T10:41:24Z

Show changes

>Admin at 18:58, 31 January 2006

2006-01-31T18:58:26Z

New page

[[Category:Category Perihelions Atari ST M68000 tutorial]]

The Atari ST M68000 tutorial part 4 â€“ of the ways of addressing memory

So, finally; addressing! Before writing this, I read the first two chapters in Steve Williamâ€™s Programming the 68000, and it was very good reading. He explained some things that I did not really go into, and above all, he has extensive explanations of addressing, before going into any code. Well well, all I can say is that I have a bit more pragmatic approach, this is after all a tutorial, and the aim is for you to learn through learning. Theory will usually only be covered in connection with practice. With this in mind, I urge you to get your hands on some M68K book and study it, because it goes through things more in theory than I do. You will probably find some of these books on some dusty bookshelf in your local library.

You should have a pretty good idea what memory is, and also what the memory registers do. Memory is simply put the computers warehouse for storing numbers. Numbers are stored in binary format, that is, only 1â€™s and 0â€™s (refer to tutorial 2 for information on this). There are also standard formats for how many 1â€™s and 0â€™s are stored. The M68K has three; byte, word and longword. A byte is 8 1â€™s and 0â€™s, a word is 16 and a longword is 32. So the quantities have the following storage capacities.

Name 1â€™s and 0â€™s Capacity
byte 8 2^8 = 256
word 16 2^16 = 65536
longword 32 2^32 = 4294967296

So, move.w means move a value, with word size. If we move a value that is bigger than word size (value > 65536), the value will be truncated (cut off), since we tell the computer to only move 16 1â€™s and 0â€™s. The term â€œ1â€™s and 0â€™sâ€ is called a bit. So, a byte contains 8 bits, never ever never confuse bits with bytes. The capacity is also somewhat of a misnomer. Since computer start counting at 0, the maximum value containable in a byte is 255. Also, in order to have negative numbers, the range of a byte is usually -128 to +127. Arithmetic that does not deal with negative numbers is called unsigned, and when negative numbers are involved, itâ€™s called signed arithmetic.

Now, we can move on to addressing modes I think. Each address is a reference or pointer to a place in memory. An address does not point to specific bits, but rather to bytes, meaning that address $2 does not point to the second bit in memory, but rather points to the second byte, which begins with the 9th bit in memory.

Address register Contains
A0

$2

Memory Contains
$1 %10101010
$2 %01010101
$3 %10101010

If we moved the byte that address register a0 pointed to, we would get %01010101, but if we moved the word that a0 pointed to, we would get %0101010110101010. If we simply moved the value of a0, we would get $2. There is a great difference to getting the value an address register points to, and the value in the address register. When we want something the register points to, we use parentheses around the address register, like this (a0). So, (a0) means the value of the memory place that a0 points to, in this case %01010101, and simply a0 (without parentheses) means the value in a0 itself, in this case $2.

You can also put â€˜+â€™ and â€˜-â€˜ characters before or after the address, meaning that you wish to increase or decrease the address registers value, either before or after the operation has been performed (called post or pre increment or decrement). Therefore, move.b (a0)-,d0 means put the value of byte size that a0 points to in d0, then decrease a0 with one. The value that the address will be manipulated with, is dependent on the memory chunk size, if itâ€™s byte, then 1, if word 2 and longword 4, in order to keep up with the changes. This is ideal for moving large areas of memory, you put your move instruction with post increment in a big loop. Christ, it feel like Iâ€™ve explained this very poorly, but donâ€™t worry, it will become clear with time I think, and especially after this example.

Memory Contains
$1 %00000001
$2 %00000010
$3 %00000011
$4 %00000100
$5 %00000101
$6 %00000110
$7 %00000111

$8

%00001000

a1 $1
a2 $2
a3 $3
a4

$4

Command Effect
move.b (a1),d0 d0 = %00000001
move.w (a1),d1 d1 = %0000000100000010
move.b (a3)+,d2 d2 = %00000011, a3 = $4
move.b (a3),d2 d2 = %00000100
move.l #$3,a3 a3 = 3
make a3 point to $3
move.b $1,d0 d0 = %00000001
put the value of $1 in d0
move.w -(a3),d3 a3 = 1, d3 = %0000000100000010
move.l #$1,a1 a1 = 1
move.l #$5,a2 a2 = 5
loop 4 times
move.b (a1)+,(a2)+
end loop

Result
$1 %00000001
$2 %00000010
$3 %00000011
$4 %00000100
$5 %00000001
$6 %00000010
$7 %00000011
$8 %00000100

As you might have noticed, if you studied the example thoroughly, when you want an address register to point to a place, you use # when giving the address, but when you want the content of the address of a memory location, you donâ€™t use #. Thus, if you want a0 to point to $100, you use move.l #$100,a0. But if you want the value of memory address $100 to be put into d0, you use move.l $100,d0. So, with a â€˜#â€™, you have a value, but without â€˜#â€™, you have a pointer.

I think that should cover it nicely. These memory addressing modes are our main concern, however, there are some more. You can use two address registers in order to get index (place of pointer), or you can add either a data register or a fixed value to an address. These are pretty self explanatory and youâ€™ll see when they come by. For example move.b (a0,a1),d0 means move the memory value pointed to by a0 + a1 into d0.

Now, in order to get an even firmer grip on traps, which seem to be hard to grasp, Iâ€™ll explain a bit more about the stack pointer. The trap part is the one Iâ€™ve had to edit the most because it was unclear. The stack pointer works like any other address register, the only difference is that some functions have the stack pointer as default address pointer, for example, traps. The idea of the stack is something that you can put data in, the last data entered is the first data that comes out, like spring loaded platforms for plates in cafeterias. When you put data on the stack, itâ€™s called push, and when you retrieve it again, you pop. So if you push the numbers one and two onto the stack, and then pop two items, you will get two and one (last in, first out; LIFO).

When pushing (putting items on the stack), you address it using pre-decrement addressing mode, and when popping, post-increment. This means that if the stack from the beginning points to $100, it will point to lesser and lesser values as you push data, and will increase in value as you pop.

a7 $100
move.w #10,-(a7) push 10 onto the stack
a7 $98
move.w #8,-(a7) push 8 onto the stack
a7 $96
move.b #1,-(a7) push 1 onto the stack
a7 $95 uneven address, be careful
move.b (a7)+,d0 pop stack into d0
a7 $96
move.w (a7)+,d1 pop stack into d1
a7 $98

As you see, the stack clears itself up when using push and pop instructions. However, when we use traps, the BIOS, XBIOS or GEMDOS wonâ€™t clear up the stack for us, so in order for the stack to keep the correct address, we have to add a certain number at the end of the trap call. If we donâ€™t do this, the stack will not point to the correct address, and when you start pushing and popping, everything will be out of alignment. Also, of interest to note, is that when you go into super mode, the user stack is replaced by the super stack, so it needs to be backed up in order to be restored later, when we switch back into user mode again.

When we already are into talking about memory and addressing, I thought Iâ€™d cover how to make your own variables and what the text to the leftmost bit really is. As you must have noted, all instructions are one tab in, so to speak, while the name of subroutines and variables are at the leftmost in the text, well, there you have it :) Whet happens when you put text to the leftmost in your source code, is that you tell the assembler that that memory position, is also known as the text you entered. Every line of source code has its memory value, which of course is some hex value, so instead of trying to figure out that hex value, you tell the assembler that â€œhenceforth, this line shall be known as [whatever you write]â€. Also, any text written after the instruction, is treated as comments and are passed over by the assembler. You may also use a â€˜*â€™ to denote comments. Comments beginning with a â€˜*â€™ can be inserted everywhere. Disclaimer; the "actual memory position" values are purely for example and have nothing to do with real life (or computers).

Actual memory position Label Commands Comments
$0 first_line move.w #10,d0 easy as pie
$2 move.w #$0,a0
$4 bra a0 moves to $0
$6 bra first_line moves to $0
$8
$a * a nice comment

$c
exit clr -(a7) never reached
$e trap #1 clean exit

The command bra, for Branch, is used to jump to different memory positions, what it does then is to alter the value of the program counter (PC). You remember, the address register that holds the position of the next instruction to be executed. Branching will be covered extensively in the next tutorial. Since variables are just chunks of data at a certain memory position, they are defined in almost the same way. You have a name for the variable, and then you say either dc.N, where N is either b, w or l for byte, word or longword, or ds.N. DC stands for Define Constant, and DS is Define Storage.

DC is a variable, while DS is a large storage area of memory. The number after DC is the initial value of the variable, and the number after DS is how many variables of the same type you want. DS is used for creating big memory spaces that you want to put stuff into later, like a bitmap or so, more on this in another tutorial. The DC area should be denoted by a "section data", and the DS section should be denoted by a "section bss" (Block Storage Segment). Section data comes first, and section bss next, these areas are to be put last in the code.

section data

temp dc.l 0 a longword sized chunk of memory, given value 0
section bss
storage ds.w 4 four words after one-another
storage2 ds.l 2

two longwords after one-another, since one longword is two word storage and storage2 have the same size

I didnâ€™t come up with any creative way to use our new-found knowledge of addressing modes, so I just made some changes to the program we already have. For example, an unnecessary putting of the background colour memory in a0 instead of just accessing it directly, and moving the temp storage from d0 to the stack instead.

jsr initialise jump to initialise
move.w $ffff8240,-(a7) push old colour to stack
move.l #$ffff8240,a0 a0 points to colour 0
move.w #$700,(a0) put $700 where a0 points
move.w #7,-(a7) wait for a keypress
trap #1 call gemdos
addq.l #2,a7 clear up stack
move.w (a7)+,(a0) pop from stack
jsr restore jump to restore
clr.l -(a7) clean exit
trap

#1

call gemdos

initialise

* set supervisor

clr.l -(a7) clear stack
move.w #32,-(a7) prepare for user mode
trap #1 call gemdos
addq.l #6,a7 clean up stack
move.l

d0,old_stack

backup old stack pointer

* end set supervisor

rts restore

* set user mode again

move.l old_stack,-(a7) restore old stack pointer
move.w #32,-(a7) back to user mode
trap #1 call gemdos
addq.l

#6,a7

clear stack

* end set user
rts

section data

old_stack
dc.l 0

That was that, I hope you know enough about addressing now to push on. In the next tutorial we will probably cover the graphics memory a bit, and what you can do with it. This means weâ€™ll finally get some action people! Iâ€™m starting to get bored of only changing the colour of the background, arenâ€™t you? We have covered most of the basic theory I think, which means that in the future there will be more practical coding, like techniques for scrollers, moving sprites, making rasters and stuff like that.

Warrior Munk of poSTmortem 2002-04-08

â€œTarget that explosion and fire.â€

- Star Trek VI, the Undiscovered Country

Last edited 2002-06-14

Perihelion tutorial 4 - Revision history

>Niceguyuk: Fixing unicode chars

>Wongck at 03:31, 19 February 2012

>Wongck at 14:33, 12 October 2011

>Silver Surfer: clean up

>Silver Surfer: clean up

>Muguk at 10:41, 1 February 2006

>Admin at 18:58, 31 January 2006