STA POS+2,X ve STA POS+2,Y kullanımları doğru. Ancak STA (POS+2,X) kullanımı yanlış. Parantez kullanacağımız zaman STA (POS+2),X şeklinde X'i dışarda bırakmak gerekiyor. Y yazmacı için tam tersi bir durum var. STA (POS+2,Y) şeklinde kullanmak gerekiyor.
Peki X ve Y arasındaki bu farkın sebebi nedir? Daha önemlisi parantez kullanımının amacı nedir? Sonuçta bu komutların hepsi akümülatördeki değeri POS+2+X(veya Y) adresine kopyalamayacak mı?

sta POS+2,x diye bir opcode da yok aslında. Bu senin kullandığın derleyicinin bir güzelliği sana. Yani diyelim ki;
POS = $1000
sta POS+2,x
derlendiğinde;
sta $1002,x
şekline dönüşür. Buradaki POS+2'lerin tamamı aslında POS diye sadeleştirilebilir, dediğim gibi burada önemli olan sadece X ve Y registerlarının kullanım yapıları.
sta söz konusu olduğunda.
sta ZEROPAGE_ADDRESS
sta ZEROPAGE_ADDRESS,x
sta ADDRESS
sta ADDRESS,x
sta ADDRESS,y
sta (ZEROPAGE_ADDRESS,x)
sta (ZEROPAGE_ADDRESS),y
bunlar mevcut, valid opcodelar.
sta ZEROPAGE_ADDRESS,y
sta (ZEROPAGE_ADDRESS)
sta (ZEROPAGE_ADDRESS),x
sta (ZEROPAGE_ADDRESS,y)
bunlar valid değil, işlemcide böyle opcodeler yok.
sta (POS+2,x) bu bağlamda valid ama POS+2'nin değeri zeropage'de yer almak koşuluyla ($00-$ff aralığı).
Edit: Sorunun ikinci paragrafını cevaplamamışım.
Parantez "address pointer" anlamına geliyor. Yani parantez olmadan;
sta $74
dediğinde accumulator'deki değer hafızanın $74 yani $0074 adresine yazılıyor. Ancak;
sta ($74),y
ya da
sta ($74,x)
kullandığımızda bu adreslerin işaret ettiği hafıza adresine değer yazılıyor. Şöyle ki x ve y sıfır değerinde olduğu durumda her ikisi de;
$74 : low byte
$75: high byte
olacak şekilde 16 bitlik bir adres okuyor. Örneğin;
$0074 : $8c
$0075 : $a4
olduğu durumda bu;
$a48c
adresine denk geliyor ve buraya accumulator değeri yazılıyor. Ancak x'in parantezin içinde, y'nin dışında olmasının bir farkı var elbette ki.
sta ($74,x)
söz konusu olduğunda $74'e değil $74+x adresine yazılıyor accumulator'ün değeri. Yani x'in değeri $04 ise $74'den değil $78'den itibaren adresleri okuyor, kısacası low byte $78, high byte $79'dan okunuyor.
sta ($74),y
durumunda ise her zaman low byte $74 ve high byte $75'den okunuyor. Deminki örneğe göre $a48c alınıyor ele. Ama buna y'nin değeri ekleniyor. Örneğin y'nin değeri $12 olduğu durumda $a48c'ye değil $a48c+$12 = $a49e adresine yazılıyor accumulator değeri.
Özetle durum bu.

Skate'in de belirttigi gibi (zp),y ve (zp,x) iki bağımsız adresleme modu. Nasıl çalıştıklarını da Skate açıklamış ben de bunların kullanıldığı senaryolar hakkında konuşayım.
(zp),y modunun iki kullanımı vardır:
- elinde bir grup tablo (yani her elemanı aynı tip olan: integer array gibi) var. Bu tablolardan birine erişip içinden tek bir değere indexleyip erişmek istiyorsun. Bu durumda tablonun başlangıç adresini zero page'de iki bayta yazıp bu mod ile erişebilirsin.
- elinde bir grup nesne var (yani farklı üyeleri farklı anlamlara gelen:asker nesnesi (hit point, bullets, name vs)). Bir nesnenin bir üyesine ulaşmak istiyorsun. Nesne'nin başlangıç adresi zp'ye erişilen üyenin offset'i y'ye.
(zp,x)
- elinde bir grup pointer var (yani pointer array gibi). Bu pointer'lardan n'incisine erişmek istiyorsun.
Açıkçası ben bugüne kadar hiç (zp,x) kullanmadım. (zp),y çok kullandım tabi. Ama son yıllarda bir refleks gelişti. Ne zaman kendimi (zp),y kullanırken bulursam hemen bunun yerine bu rutini komple zero page'e kopyalayabilir miyim diye düşünüyorum. Eğer bunu yapabilirsem o zaman o zp adresine iki baytı yazan sta'lar 3 cycle kalmaya devam ederken lda (zp),y ise lda zp,y dönüşmüş oluyor ve bir cycle azalıyor. Bu trik snapshot'taki tünel ve gezegen part'larını %20 civarı hızlandırmıştı.

@Nightlord: (zp,x) kullanmadığını söylemişsin ya, ben de zp,x'i x kadar ilerden pointer almak amacıyla kullanmadım. ancak zaman zaman lda (zp) ya da sta (zp) gibi birşey yapmak gerekiyor ve bu opcode olmadığı için de (zp),y ya da (zp,x)'i sıfır index değeriyle kullanmak gerekiyor. o andaki loop durumuma göre x mi y mi hangisi müsait bakıyor ve ona göre kullanıyorum. yani ben (zp,x) kullandım ama x hep sıfırdı. sen de belki bu şekilde kullanmış olabilirsin diye düşündüm.

Beklediğimden çok daha detaylı cevaplar gelmiş. Şimdi elimizde iki adet adresleme modumuz var. STA komutu için yazarsam:
Zeropage indirect indexed addressing:
Bu mod sadece Y yazmacıyla çalışıyor. 16 bitlik bir adresi zeropage'de iki bayt ile göstermeye yarıyor. Düşük öncelikli baytı işaret ettiğimiz adrese, yüksek öncelikli baytı bir sonraki adrese yazıyoruz. CPU önce zeropage'e gidiyor. Zeropage'de gösterilen adresi okuyup, index kadar ilerisine gidip akümülatörü oraya yazıyor.

POS = *$1000<br /><br />LDA #$00<br />STA POS+2         ;#$1002 = $00<br />LDA #$04<br />STA POS+3         ;#$1003 = $04<br /><br /><br />LDA #$20<br />LDY #$29<br />STA (POS+2),Y    ;#$0429 = 20

Buradaki örnek kodda STA komutu POS+2 ve POS+3 adreslerinde $00 ve $04 değerlerini okuyup $0400 adresini buluyor, $29 bayt ileri gidip, $0429 adresine (ikinci satırın başına) $20 değerini yazıyor. 
Zeropage indexed indirect addressing:
Bu modda ise tam tersi bir durum var CPU belirtilen adresten sonra index kadar yürüyüp orada gördüğü değeri uygulama adresi olarak kullanıyor.

<br />POS = *$1000<br /><br /><br />LDA #$29<br />STA POS+2           ;#$1002 = $29<br />LDA #$04             <br />STA POS+3           ;#$1003 = $04<br /><br /><br />LDA #$20<br />LDX #$02<br />STA (POS,X)          ;#$0429 = 20<br />

Buradaki örnek kodda STA komutu POS adresini okuyup 2 bayt ilerden POS+1 ve POS+2 adreslerinden $29 ve $04 değerlerini okuyor. Sonucunda $0429 adresini buluyor ve buraya (ikinci satırın başına) $20 değerini yazıyor.
O zaman zeropage indexed indirect adressing modunu önceden belirlenmiş alanlarda efekt göstermek gibi işlerde kullanabiliriz. Bir vektör tablosu oluşturup, kodumuzun farklı index değerine göre farklı adreslerde çalışmasını sağlayabiliriz. Peki X ve Y yazmaçlarının farkı nereden geliyor? Neden ilk metodda sadece Y kullanılırken ikincisinde sadece X kullanılabiliyor?

Kısa cevap "by design".
Uzun cevap aşağıdaki videoda vardır sanırım. 🙂
http://media.ccc.de/browse/congress/2010/27c3-4159-en-reverse_engineering_mos_6502.html

@wizofwar: ufak bir typo yapmışsın sanırım. Verdiğin her iki örnekte de hedef adrese $29 değil $20 yazılıyor.
Adresleme modlarının her yazmacı neden aynı derecede desteklemediği güzel bir soru. Bu soru her komutun neden her adresleme modunu desteklemediği şeklinde daha da genelleştirilebilir. Mesela INC komutu burada bahsettiğimiz iki adresleme modunu da desteklemez.
Bunun cevabı 6502'nin komutlarının gerçekleştirilmesinde kullanılan bir tasarım kararına dayanıyor.
Çoğu CPU içinde microcode denilen bir dil ile tek tek komutları gerçekleştirir. Microcode komutları asm komutlarından bile daha alt seviye şeylerdir. Mesela adres bus'ı oluşturan iki 8 bitlik yazmaca bayt yazarlar falan. yani bir register'a bellekten adres yüklemeye yarayan bir asm komutu genelde 3 veya 4 microcode komutunda uygulanır. Pekçok CPU bu şekilde aynı adresleme modunu bütün registerlarına uygulayabilir çünkü çok küçük microcode değişiklikleri ile CPU'nun maliyetine çok etki etmeden bu komutlar eklenebilir.
6502 ve 6510'da ise microcode kullanılmamış. Tamamen custom kombinasyonel devreler kullanılmış ve bu şekilde fiyat düşürülmüş. Bu durumda herhangi bir adresleme moduna herhangi bir komutun veya yazmacın desteğini eklemek demek cpu'ya ilave logic devre eklemek demek ki bu fiyatı etkiliyor. Bu yüzden bir nevi köşelerin kırpılması durumu diyebiliriz.
CPU'ların içi ve kombinasyonel devreler hakkında şurada daha detaylı şeyler yazmıştım

Skate'in linkini verdiği video ilaç gibi geldi. Aslında daha önce denk gelmiştim fazla teorik/akademik olacağını düşündüğümden izlememiştim. Hata etmişim.
Anladığım kadarıyla işlemcinin decoder ve sequencer kısımlarını basit tutmak için opcode'lar minimize edilmeye çalışılmış. Kullanılan decoder & sequencer sistemi olayın sorumlusu. Aynı zamanda illegal opcode'ların da sebebi. Sorularımla elektronik mühendisliğinin konularına çoktan girdim, derinlere doğru gidiyorum ama acaba Nightlord'un bahsettiği microcode sisteminin kullanılmaması RISC felsefesinin bir getirisi mi? Yani bütün RISC işlemcileri aynı decoder & sequencer sistemini mi kullanılırlar?
Video hakkında yazmam gerekirse: "Who has been on the the original design team." espirisi bayağı iyimiş. 6502.org ekibinin işlemcinin orjinal tasarım dökümanları ve tasarımı hakkında hiçbir bilgiye ulaşamamış olması çok ilginç geldi. Bir çok insanın merakını cezbeden bu state-of-art ekipmanların tasarımcılarının gözünde standart bir iş'ten öte birşey olmaması çok garip. Aynısını Dave Haynie'nin bir röportajında okumuştum. VIC-II'nin özelliklerini nasıl seçtiklerini anatırken elimizdeki işlemci ve TV standartlarıyla yapılabileceğin en iyisini yaptık diyordu. 16 renkten fazlasını kullanmayı veya daha çok sprite göstermeyi vs. hiç düşünmemişlerdi. C128'i için tekrar debug'la uğraşmamak için VIC'i olduğu gibi bırakmışlardı vs. C64'ün sevenlerinin çok beğendiği, sevmeyenlerinin dalga geçtiği renkleri de Chroma değerleri arasında sabit açılar olacak şekilde luma değerleri de birbirinden farklı olacak şekilde (S&B monitörde de kullanılabilmesi için) seçildiğini biliyoruz. Muhtemelen bu renklere çalışacak grafikerleri pek fazla düşünen olmamıştı. Steve Wozniak gibi adamlar olmasa iyiden iyiye takıntılı olduğumu düşünmeye başlayacağım.
Bu arada benim için bu başlığın en büyük getirisi: "64K Ram system 38911 bytes free" yazısının rom'dan okunan sabit bir şey olduğunu zannediyordum. Halbuki bütün Commodore bilgisayarlarında kullanılan sabit bir kod her seferinde hafızayı sayıp 38911'i bulup yazıyormuş.  Bunu öğrendim.
@Nightlord: koda bakamadım. Vaktim olunca düzelteceğim.

acaba Nightlord'un bahsettiği microcode sisteminin kullanılmaması RISC felsefesinin bir getirisi mi? Yani bütün RISC işlemcileri aynı decoder & sequencer sistemini mi kullanılırlar?

Burayı biraz açalım. 6502 ailesi genelde CISC kabul edilir. RISC'in çok kesin bir tanımı olmamakla beraber, bir CPU'yu RISC yapan başlıca özellikler,
* genelde sabit uzunlukta instructionlar olması(mesela 6502'de inx, lda #0, lda $1000 gibi bir, iki, veya üç baytlık instructionlar olmaması)
* load store mimarisi (yani alu işlemlerinin sadece yazmaçlar arasında yapılabilmesi, bellekten yapılan tek etkileşimin bir registera yükleme veya registerdaki değeri yazma olması). Örneğin 6502 adc $1000 diye bir bellekteki değeri cart diye alu'ya sokabilir.
* microcode yerine genelde hardwired logic kullanmak RISC işlemcilerde sıkça rastlansa da microcode kullanan RISC işlemciler de var.
bu sabit uzunluktaki komutlar hardwired decoder olayını kolaylaştırır. Buna ilaveten CPU'nun bir komutu işletişi aşağı yukarı hep aynı 3-5 basamakta yapılabilir. Böyle olunca CPU'ya bu 3 stepi (fetch, decode, execute) yapan donanımı koyup pipeline oluşturabilirsiniz. Komutları bu pipeline'dan ilerletirken, birinci komut 2. basamağa geçince bir sonraki komutu birinci basamağa alarak bütün pipeline'ı doldurabilirsiniz. O zaman da bir komut 3 cycle alıyor bile olsa pipeline sayesinde RISC işlemciler ortalamada her cycle'da bir komutu throughtput edebilir.

@wizofwor: Meraktan soruyorum kardeşim. Bu başlığı açtığın sırada ne tarz bir projeyle uğraşıyordun? Yani muhabbet çok fazla donanıma kaydı ve sen de bundan memnun görünüyorsun. Emülatör / simülatör tarzı bir şeyler mi var aklında, yoksa sen 6510 assembly kurcalamaya karar vermiştin de muhabbet mi bu kadar donanıma kaydı ya da benim şu sıralar vakit buldukça Amstrad CPC için yaptığım gibi sadece öylesine döküman okuyup takılıyor muydun?

@Skate: Senin deyiminle rastgele döküman okuyup takılırken, CBM prg studio'nun içersindeki assembler'ın STA (POS+2,X) kodunu hata vermeden derlediğini ve doğal olarak derlenen kodunun çalışmadığı ile ilgili bir yazışmaya denk geldim. Buradan bir merak uyandı. Sizlerden: "Çünkü X registeri hede, Y registeri hödö durumlarında kullanılmak için düşünülmüştür." gibi bir cevap beklerken konu birden derinleşti. Bu altta yatan sebep olayının da oldukça hoşuma gittiğini inkar edemeyeceğim.
@Nightlord: 6502 görece basit bir işlemci olduğu için bende hep RISC algısı oluşturmuş. Baktığımız zaman her cycle'da bir komut işleyemese de pipeline olayı 6502'de de var. Hardwired decoder'dan zaten bahsettik. Yani RISC konseptine ait bazı esinlenmeler olmakla beraber kompleks adresleme modları ve ALU'nun direk bellek üzerinde işlem yapabilmesi gibi kesinlikle CISC tarzı yönleri de var. Kısaca "best of both words" durumu var. 6502.org'da nonCISC, pre-RISK gibi tanımlandığı da gördüm. Sanki Chuck Peddle maliyeti düşürmek için kastırırken istemeden doğru yolu bulmuş gibi.

wizofwar: ben de o yüzden "genelde" CISC kabul edilir demiştim. 6502 camiasında "o aslında ilk RISC idi sonra ARM ondan esinlendi" falan gibi düşünen bir kitle var. Ama bu azınlık ve zaten yaptıkları savunma biraz felsefi boyutta.
Yalnız 6502'de pipeline yok. fetch/decode/execute basamakları var elbette ama pipeline diyebilmemiz için cpu'nun aynı anda birden fazla komutun farklı basamaklarını işletebiliyor olması lazım. 6502 bunu yapamıyor. Bir komutun bütün basamaklarını bitirdikten sonra bir sonraki komutu fetch edebiliyor ancak.

6502'de pipelime olduğu fikrini skate'in videosunda 35:08'den sonraki instruction decocoding ve timing generator muhabbetinden edindim. Yanlış mı anladım acaba? 

video'nun tamamını izleme şansım olmadı ama 35.00 komşuluğundaki 3-4 dakikayı izledim. Bu enteresan bir durum.
1- Bilmediğim birşey öğrendim. her komutun fetch cycle'ını bir önceki komutun son cycle'ı ile örtüştürdüğünü bilmiyordum. Bunu biraz da olsa pipelining adledebiliriz. Yani o ezberlediğimiz komut cycle uzunlukları aslında hep bir cycle eksik imiş. Inx 2 değil 3 cycle imiş. lda $1000 4 değil 5 cycle imiş. Ama hep bir cycle fetch bir önceki komutun son cycle'ına kotarıldığı için komutlar normalde olacaklarından 1 cycle eksik çalışıyor pratikte
2- Dolayısıyla buna pipeline atası 6502'dir gibi bir cümleye çok da itiraz etmem. Hala bu 6502'yi RISC işlemci adletmek için yeterli değil ama "RISC'in öncüsü" gibi bir tanımlamayı destekleyen bir olay.

@Nightlord: Yanlış anlaşılmasın benim 6502 RISC'tir diye bir iddiam yok. Ama RISC/CISC kavramlarını ilk öğrendiğim günden beri aklımda canlanan düşünce bu yöndeydi. Sen hayır o CISC'tir deyince bir an ters köşeye yattığımı düşündüm ama çabuk toparlandım sanırsam 🙂
Not: Yukarıdaki örnek kodları ve açıklamaları düzelttim. Ufak tefek 1-2'de comment ekledim.
Yan soru: 'most/least significant byte' terimi için kullandığım 'yüksek/düşük ağırlıklı byte' çevirisi doğru mu? Yoksa biraz Microsoft Türkçesi mi yaptım?