Флейм
GameDev.ru / Флейм / Форум / Меряемся придуманными машинными архитектурами (4 стр)

Меряемся придуманными машинными архитектурами (4 стр)

Страницы: 1 2 3 4 5 6 7 Следующая »
TonalПостоялецwww23 мая 20186:21#45
=A=L=X=
> Это в точности подход Motorola 68000 - 16 РОН делится на 8 регистров данных и 8
> регистров адреса. Между ними возможны пересылки, но полная арифметика возможна
> только над первыми, а косвенная адресация - только через вторые.
для удобства можно сделать по возможности равноправными для простой арифмеики и логики, а разделить на косвенную адресациюи и умножение-деление,
вообще, это как пример использования неявной адресации, можно использовать по разному. например  8 регистров каксвенной адресации разделить на группы( 4 штуки(2 с автоинкрементом +2 савтодекрементм) и 4 без автоин(де)кремента. Или в регистре флагов обычно есть место, можно одним битом управлять автоин(де)крементом

Правка: 23 мая 2018 6:31

=A=L=X=Постоялецwww23 мая 20186:30#46
Tonal
> для удобства можно сделать по возможности равноправными для простой арифмеики и логики
Почти так и сделано - адреса же  тоже нужно нередко складывать, для базовых адресов массивов, например, поэтому суммы доступны для регистров адресов у них тоже. Более того - в первых реализация АЛУ m68k было 16-битным (именно в 16-битной SegaMega Drive такой и трудится, хотя система команд 32-битная) и действия над data32 выполнялись за много тактов, зато складывание адресов с адресами и константами было 32-битным, ибо делалось не блоком АЛУ и в этих первых полу-16-битных ревизиях было выгодно складывать как ни странно данные как адреса.
TonalПостоялецwww23 мая 20187:51#47
=A=L=X=
> было выгодно складывать как ни странно данные как адреса.
Да и в х86 иногда удобно было адресной арифметикой пользоваться, типа LEA EAX, [EBX+ECX]

В 8051 тоже есть один 16-битный регистр DPTR и команда его инкремента, для общей арифметики правде не очень пригодна(команды загрузки и выгрузки нивелируют эффект).

Правка: 23 мая 2018 7:56

=A=L=X=Постоялецwww23 мая 20188:07#48
Родил вариант архитектуры с двумя байтами на опкод в среднем.
Нечто среднее между RISC/CISC, опкод от 1 до 2 байт, плюс immediate-данные от 0 до 2 байт на команду.
16 16-битных регистров R0-R15. R15 - счётчик команд. перед началом выполнения текущей команды он смотрит на следующую, при изменении происходит переход на новый адрес.
К регистрам можно обращаться как к байтам или словам принудительно прописывая суффиксы W или B: R0B или R15W, байтовое обращение работает с нижней половинкой.
Все опкоды разбиты на группы по 4 бита, так что их легко выписывать как 16-ричные числа, а сами команды условно (деление такое несколько условно) разбросать на 16 базовых опкодов.
В свою очередь во втором опкоде чаще всего указаны номер двух регистров от 0 до 15, поэтому он чаще всего записывается как Rr.
Итак:
===========================================

0X Rr [B/W]: прямая загрузка регистра R с влиянием на флаги
(то есть верхний полубайт первого опода равен 0, 
  нижний - уточнению команды, которое расписано ниже,
  второй байт задаёт номера регистров R и r,
  плюс возможно необязательное данные - байт или слово (B/W), см. ниже)
бит X0  - 0 если работаем с байтом, 1 если работаем со словом (byte/word)
бит X1  - 0 если операция загрузки, 1 если операция инкремента/декремента (load/increment)
биты X23 при load:
  0-просто копируем в R регистр r, 
  1-копируем регистр добавляя к нему imm8, 
    к слову добавляется с расширением знака,
  2-копируем регистр добавляя к нему imm16
  3-загружаем поле r в R не как регистр, а как число -8..-1,+1..+8
биты X23 при increment:
  0-в R копируется r+1
  1-в R копируется r-1
  2-в R копируется r+2
  3-в R копируется r-2

Примечания: операция обновляет флаги,
  некоторые комбинации бит в X противоречивы
  и запрещены под будущие расширения команд.

Примеры возможных команд (в скобках занимаемое число байт всей команды):
(2) R=r    ; влияет на ZF, очищает CF!
(3) R=r+imm8 (-128..+127)
(4) R=r+imm16 (-32768..+32767)
(2) R=imm4 (-8..-1, +1..+8) ; ZF=0, CF=0
(2) R=r+imm2 (-2,-1,+1,+2)

===========================================

1X Rr [B/W]: прямая загрузка регистра R без влияния на флаги

то же что и 0X, но перед командами прописываем !:
!R=r

===========================================

2X Rr [B/W]: косвенные загрузки/сохранения
бит X0  - byte/word
бит X1  - 0 - если загрузка, 1 - если сохранение (load/store)
бит X23:
  0 - R загрузить с адреса в регистре r
  1 - то же самое, но добавить адресу immediate-байт со знаком 
  2 - то же самое, но добавить к адресу immediate-слово

Примечание: X32 не может быть равен 3, задел под будущие расширения

Примеры всех команд:
(2) R=[r]
(3) R=[r+imm8]
(4) R=[r+imm16]
(2) [r]=R
(3) [r+imm8]=R
(4) [r+imm16]=R

===========================================

3X Rr [B/W]: косвенные загрузка/сохранение 
  с авто-инкрементами/декрементами

X0 - byte/word
X1 - load/store
X23:
  0 - преинкремент,
  1 - постинкремент,
  2 - предекремент,
  3 - постдекремент

Примечание: команда с постинкрементом R15 
  эквивалентна загрузке immediate-данных

Примеры команд:
(2) R=[++r]
(2) R=[r++]
(2) R=[--r]
(2) R=[r++]
(2) [++r]=R
(2) [r++]=R
(2) [--r]=R
(2) [r++]=R
(3) R=imm8  ; Rb=[R15++]
(4) R=imm16 ; Rw=[R15++]

===========================================

Косвенные загрузки/сохранения по адресу как
  суммы двух регистров:
4t Rr - load byte
5t Rr - load word
6t Rr - store byte
7t Rr - store word

(2) R=[r+t]
(2) [r+t]=R

===========================================

Арифметико-логические операции:
8& Rr - arithmetic_1 byte
9& Rr - arithmetic_1 word
A& Rr - arithmetic_2 byte
B& Rr - arithmetic_2 word

Пример:
(2) R &= r
Примечание: под & понимается символ двухоперандной операции, например:
R5 += R7
Если не учитывать деление на байт/слово, то есть 2 опкода для
таких операций, чтобы всего их было 32 возможных комбинации, 
что можно увидеть в таблице этой темы на первой странице.
Часть из них, например прокрутки, могут воспринимать r не только
как номер регистра, но как imm4-данное от 0 до 15.

===========================================

СX B/W - Ветвления
бит X0 - если 0, то immediate-данное - байт, иначе - слово
бит X1 - если 0, то данное загружается в R15, 
  иначе - прибавляется к нему,
  байт прибавляется с расширением до знака,
  загрузка байта скорее всего должно быть синонимом вызова прерывания.
бит X2 - если равен 1, то предыдущее значение R15 
  сохраняется в R14 (Link Register) для реализации подпрограмм
X3 - если 1, то команда становится условным jmp rn с условием в битах X012

Примеры:
(2) jmp rn, label; jump relative near
(3) call af, label; call absolute far
(3) call rf, label; call relative far

===========================================

Зарезервированные базовые опкоды.
D...
E...
F...

Разложение опкодов на битовые маски:

000FXXIB RRRRrrrr - LOAD/INCREMENT
0010XXLB RRRRrrrr - LOAD/STORE INDIRECT
0011XXLB RRRRrrrr - LOAD/STORE INDIRECT AUTO

01LBtttt RRRRrrrr - LOAD/STORE INDIRECT SUM
10MBMMMM RRRRrrrr - MATH/LOGIC
11000XXB          - BRANCH
11001CCC          - BRANCH CONDITIONAL

R - reg destination
r - reg source1
t - reg source2

F - update flags
XX - op subtype
I - load/increment
B - byte/word
L - load/store
M - math op
C - condition

Правка: 23 мая 2018 11:13

DexusУчастникwww23 мая 20188:21#49
=A=L=X=
> байтовое обращение работает с нижней половинкой.
А со старшей без сдвигов никак?
=A=L=X=Постоялецwww23 мая 20188:26#50
Итак, если теперь переписать копирование байт под двухбайтные опкоды, то получится:
(4) R1=DST
(4) R2=SRC
(4) R3=CNT - 1
LOOP:
(2) R0B=[R3+R2]
(2) [R3+R1]=R0B
(2) R3=R3-1
(2) JMP NZ, LOOP
Даже короче, чем в однобайтных опкодах у меня было тут ранее.

Правка: 23 мая 2018 10:23

=A=L=X=Постоялецwww23 мая 20188:28#51
Dexus
> А со старшей без сдвигов никак?

Никак. Есть арифметические команды обмена байт регистра, расширения со знаком и расширения нулём - стандартный подход в RISC, так как регистров много, то за байтами гнаться не стоит, плюс упрощается повышение разрядности.

Правка: 23 мая 2018 8:29

AlikberovПостоялецwww23 мая 20188:29#52
Нe будете банить за псевдо-оффтоп?
+ Мои RISC-попытки

Правка: 23 мая 2018 8:36

AlikberovПостоялецwww23 мая 20188:30#53
+ Мои RISC-попытки: Регистры

Правка: 23 мая 2018 8:46

TonalПостоялецwww23 мая 20188:30#54
интересный вопрос на сколько нужно условное выполнение команд, иногда оно конечно бывает полезно...
с другой стороны очень редко условное выполнение нужно одной команде, чаще это группа издвух трех и более команд подряд, и тут уже только переходы.

Может потратить эти опкоды на что то более полезное, типа битовых операций

вот сделать команды условнуй загрузки  это полезно
CMOV  A ,B ,C - IF B>C THEN A=B ELSE A=C

Правка: 23 мая 2018 8:40

DexusУчастникwww23 мая 20188:43#55
Tonal
Условное выполнение команды это фактически перепрыг через одну команду по условию. В виде псевдопрефикса. Экономия на обработке параметра смещения.

Правка: 23 мая 2018 8:46

=A=L=X=Постоялецwww23 мая 20188:47#56
Tonal
> с другой стороны очень редко условное выполнение нужно одной команде

Я когда в соседней теме начал баловаться с ассемблером на Z80 у меня довольно часто стало вылазить такое:

ld hl, other
ld a, some
cp a, some_test_value
jr nz, .skip
ld hl, another
.skip ... ; работаем с hl
то есть вилки значений - например конвертируя число в 16-ричную строку надо контролировать от 0 до 9 у тебя вычет или от A до F и так далее - в куче мест.
и вот проще было бы так:
ld hl, other
ld a, some
cp a, some_test_value
ifz ld hl, another
... ; работаем с hl

AlikberovПостоялецwww23 мая 20188:49#57
+ Мои RISC-попытки: Пример кода
AlikberovПостоялецwww23 мая 20188:51#58
+ Мои RISC-попытки: Конец

P.S.: Эмулятора нет, но есть html-дизассемблер…

Правка: 23 мая 2018 9:04

DexusУчастникwww23 мая 20188:54#59
=A=L=X=
Скипы одной строчки я делал даже без меток. Нафига ещё имена на них тратить? Просто $+3 и все. Отдельную команду (точнее даже несколько, под каждое условие) в пространстве команд резервировать - это слишком расточительно.
Страницы: 1 2 3 4 5 6 7 Следующая »

/ Форум / Флейм / Железо

2001—2018 © GameDev.ru — Разработка игр