низкоуровневое программирование. вопросы
 

Собственно, пока возникло два вопроса.

1. На это я, порывшись в юзергайдах и книжках, уже ответ нашёл. Но на всякий случай хочу удостовериться в его правильности (он в скобках).

Связан ли объём адресуемой памяти процессора с параметром его разрядности? (нет, эти параметры независимы - разные наборы выводов)


2. Как запускаются приложения? Куда передаются данные бинарных файлов на выполнение? Инструкции, содержащиеся в бинарных файлах - это инструкции процессора или опеационной системы?

1. Zawisit ot arhitekturi.
2. Esli eto ne skript, a instrukcii processora, to i wipolnyaet ih processor.

1.Ну, обьем адресуемой памяти процессора вроде как и связан с его разрядностью - если у процессора вегистры 16 бит, то и адресовать он сможет не больше 2^16=65536 байт. Для адресации используются
АДРЕСНЫЕ РЕГИСТРЫ

От размера этих регистров зависит размер памяти, к которой процессор может непосредственно адресоваться.

В процессорах первых поколений Intel 8088/8086 размер адресных регистров был 16 битов или 2 байта - максимальное число (номер байта в памяти), которое может быть записано в такой регистр, 2^16-1=65535 или, как его округленно называют - 64 килобайта

Но уже в компьютерах на базе этих процессоров возникла необходимость адресоваться к памяти размером 1024 килобайта (1 мегабайт). Чтобы выйти из затруднения с регистрами недостаточного размера, для адресации отвели 2 регистра и решили составлять адрес из 2-х частей : первая часть адреса содержит номер блока памяти как количество 16 байтовых ПАРАГРАФОВ, а вторая часть номер байта, отсчитанный от границы (начала) параграфа. Первую часть адреса назвали адресом СЕГМЕНТА, а вторую - СМЕЩЕНИЕМ внутри сегмента. Очевидно, что обе составляющие при 16-битовом регистре адреса не могут быть больше 65535

Максимальный адрес, по которому можно обратиться к памяти при такой 2-ступенчатой адресации FFFF0 или 65535 * 16 = 1048560.

Если все смещения будут максимальными - по 64 Кбайта -, то всего можно иметь до 16 сегментов. Процессоры следующих поколений имели уже более длинные регистры для хранения адресов - 80286 использует 24 битовые и позволяет адресовать напрямую до 16 мегабайт, а 80386 имеет 32-битовые регистры и может адресовать до 4 Гигабайт

2.Как уже говорилось в предыдущих темах, ассемблер заменяет аббревиатурами команды процессора.

Вот тут не понял. Можно пояснить к чему относятся операнды?

И что такое параграф и чем он отличается от сегмента?

Где до 16 сегментов?

сегмент:смещение
 

Смотри, у тебя первая часть - адрес сегмента памяти , измеряется в параграфах, тоесть сколькото раз по 16. Наприме, если сегмент равен 34, то реальный адрес, на который он указывает = 34*16=544. А смещение измеряется для более точного указания в байтах, так что если оно будет равно 7, то весь адрес, вычисляемый по формуле сегмент:смещение будет равен 544+7=551 байт.
Речь идет об оперативной памяти.

Тут 34, как понимаю, номер СЛОВА (2 байта; оно же ПАРАГРАФ???)
Но ведь в примере
65535 БАЙТ, а не СЛОВ(2 байта)

65535 - это максимальный размер числа в адресном регистре. А в этом регистре, как мы знаем каждая единица - это один параграф(сделано было, чтобы больше можно было адресовать). А теперь помнож 65535 - количество единиц на их значение 16 и получится 1МБ

Не, ну тут же явно 2 байта! (а не СЛОВА!)
Или эти примеры между собой не связаны?

2 байта это и есть слово. В начале для адресации использовали 1 регистр, но его оказалось мало, так что потом начали использовать 2 регистра и сегментную модель памяти, потом регистры начали увеличивать - 16 - 32 - 64.

Чего-то тут с этой русской терминологией можно запутаться.

Неважно. Не знаю там где как, но на PowerPC расклад такой:

2 bytes - halfword
4 bytes - word
8 bytes - double word
16 bytes - quad word

В RISC архитектурах не существует понятия адресных регистров. Две главные группы регистров это: GPR (general purpose registers) and FPR (floating-point registers). Операции с адресами происходят через GRP. Поэтому в 32-битных процессорах, приложения могут адресовать максимум 2^32 bytes, в 64-битных - 2^64. Но это не означает что максимальный объем физической памяти, который могут адресовать эти процессоры такой же.

Slanj
Ты меня окончательно запутал!

В твоих примерах
34 (СЛОВ) * 16 = 544
65535 (БАЙТ) * 16 = 1048560

вот этого я не могу понять

basturd
Ээээ... А при чём тут PowerPC? Это ты чему противопоставляешь?
И что такое RISC, точнее каким он тут боком?

metton
RISC - это Reduced Instruction Set Computer. Извини, обьяснял ночью, башка не очень варила, сам немного запутался. Просто и правда в разных учебниках все по разному называют. Давай остановимся на Зубкове (его приоритет подтвердила моя преподша, содрав добрую половину своих лекций из его книги :biggrin: ). Просто сегментную часть адреса называют номером параграфа. Но это не суть делла важно, ты ведь в программах термины не будешь писать :) . Давай так, значение сегмента адреса в двоичном виде сдвигается на 4 бита влево (что равносильно уможению на 16), полученному адресу плюсуется адрес смещения и получается реальный адрес.

Ну ты тему общую поднял. Ну вот я и обобщил. В принципе архитектуры процессоров делятся на три основные группы: CISC, RISC, и EPIC. Некотрые вещи о которых здесь упоминали имеют отношение только к CISC.

1. CISC (Complex Instruction Set Computer) - например процессоры от AMD и Intel, включая все процессоры семейства x86.

2. RISC (Reduced Instruction Set Computer) - подавляющее большинство других архитектур, таких как IBM PowerPC (Power Mac G4/G5), Sun Sparc, DEC/Compaq Alpha, MIPS.

3. EPIC (Explicitly Parallel Instruction Computing) - чипы семейства Itanium от Intel

Slanj
Вот, и я об этом же!

Вот как раз это мы сегодня с одногруппником пытались понять из Зубкова (в объяснении селекторов)! Долго пытались понять, зачем делить на 16, а затем смещать на 4 бита влево. Ведь это одно и то же! И пришли к тому, что это просто чтобы он (селектор) умещался в 16 бит. Правильно?
А селекторы хранятся в CS, DS, ES, FS, GS и SS, так? А где хранятся смещения?

и ещё, не понял эту фразу из Зубкова:
"...в защищённом режиме адрес начала для каждого сегмента хранится отдельно, так что возможно 2^46 (64 терабайта) различных логических адресов в формате сегмент:смещение (программа может определить до 16384 сегментов, каждый из которых до 4Гб)..."
Что значит - хранятся отдельно и откуда взялись эти числа?

И вот ещё, пока не забыл. Из Абеля.

Зачем нужен бит чётности и где он хранится? Почему число битов со значением 1 не должно быть чётно?

Книга вообще, наверное толковая, но в ней, как и во многих других такое количество неустоявшейся (и не объяснённой) терминологии, что очень многое приходится додумывать.


basturd
ОК, учту. А к какому типу относится ARM? Скорее всего, RISC?

Ну вот, мы уже идем на поправку! Ты немножко неправильно понял - селектор это есть адрес в памяти, деленный на 16. Как я уже говорил, это чтобы больше памяти адресовать. А чтобы получить реальный адрес этот селектор надо сместить на 4 бита влево или * 16. Как аналог, представь, в одном килограмме 1000 граммов, а в одном селекторе (или параграфе) 16 бит. ;)
Cs, Ds, Es, Fs, Gs и Ss - это сегментные регистры, используются для хранения сегмента адреса.
Cs - сегмент кода - код программы
Ds - сегмент данных - сегментная часть адреса расположения данных программы
Ss - сегмент стека - адрес стека
Es, Fs, Gs - дополнительные сегментные регистры, могут содержатьсегментную часть любого адреса памяти.
Смещения хранятся в Bp, Sp, Si, Di
Bp - указатель базы - хранит смещение в области данных
Sp - смещение вершины стека
Si, Di - индекс источника, индекс приемника с ними и будешь скоро работать
Si - смещение данных, которые должны быть перемещены
Di - смещение, куда должны быть перемещены
Смещение следующей выполняемой команды всегда хранится в специальном регистре — Ip

Slanj
Так, ну это я понял - смещаем селектор на 4 бита влево. На 4 бита - потому что в параграфе(слове) есть две позиции смещения - 2 байта?

Так, что-то сейчас не соображу, как это помогает нам больше памяти адресовать?

И откуда всё-таки эти числа:
Что значит - хранятся отдельно и откуда взялись эти числа?

Это помогает нам больше памяти адресовать, так как адрес теперь состоит из двух частей, в одной из которых единицы в 16 раз больше, а вторая часть для точного указания просто в единицах. Получается и адресовать мы сможем в 16 раз больше - 65535 (максимальное число, умещающееся в двух байтах) умножить 16 = 1МБ.
Насчет второго пока не задумывайся, а то опять запутаешся. Попробуй рассмотреть это немного позже.
P.S. Решил все же добавить. В защищенном режиме - 32 разрядные процессоры. Регистры у них по 32 бита. Теперь узнаем максимальное значение в 32 битах - 2^32 = 4ГБ. Программа может определить до 16384 сегментов. 4ГБ * 16384 как раз и равно 64 ТБ. Автор просто немного сократил эту операцию, оставив додумывать нам.

Slanj
опять не всё понял...
так, стоп! не сам адрес, а адрес, хранимый в регистрах?

это как??!

это понятно, это смещение. да?

так, 2 байта - это на что в данном случае? На селектор или на номер сегмента?

чё-то щас туплю...
но я упорный - пока не разберусь, не успокоюсь!

Да, мы с тобой я вижу тут долго сидеть будем. Но ничего, сам ассемблер хорошенько повторю.
1. Ну конечно, адрес, хранимый в регистрах, состоящий из сегмента и смещения.
2.Это я уже устал писать. В сегментном регистре каждая единица - это 16 бит.
3.Да, это смещение.
4.Умножается максимальное количество селекторов на их значение.

А упорство - это очень хорошая вещь, мне его очень часто не хватает :idontnow:

так, а где у нас тогда единицы в 1 бит??!!

так, понятно откуда берётся максимальное количество селекторов
непоятно, теперь не понятно, что значит значение селектора - 16 :confused:

в общем, я пошёл. ещё раз перечитаю это раздел у Зубкова, Абеля и Петцольда, и, может быть, просветлюсь ;)

1.В смещении, ты же вроде это уже понял.
2.Перечитай, это ты прав.

ARM это RISC

Смещения (offset) кодируются непосредственно в машинную инструкцию (machine instruction), поэтому они и не бывают очень большими - чаще всего 16 bit. Это имеет особое значение для RISC, т.к. в RISC машинные команды имеют фиксированную длину и кодируются 4 байтами - 32 битами. Т.е. смещение в машинной инструкции RISC съедает половину всех битов отведенных на кодирование машинной инструкции.

Slanj
Я кажется понял - тут мы показываем что в каждом сегменте есть 4 бита (16) смещений? Если да, то почему только 4, если сегмент у нас 16 бит?
Или смещение задаётся в количествах бит, а не в их адресах относительно начаала сегмента? То есть если смещение 15 пишем 1111, а не 00001111 и оно указывает на 15-ый бит сегмента?

Так а почему тогда скомпилированные ассемблером под Вынь не работают на Линуксе даже когда один и тот же проц? В этом и есть вопрос

В каждой операционной системе свои объекты, термины и понятия.
Сейчас поясню. Например, понятия Process и Thread.
В винде это одно, а в юникс-системах это другое.
Или еще пример: в винде для переключения между потоками (threads) используется вытесняющая многозадачность (preemptive multitasking многозадачный режим с приоритетами - обеспечивает операционной системе возможность захвата процессора в любой момент времени, независимо от состояния работающих приложений).

Список можно продолжать бесконечно.
Всё, что связанно с ядром операционной системы - является проблемой при портинге програм с одной ОС на другую.

Для решения подобных проблем, используется концепция виртуальных компьютеров (virtual mashines).
Пример: Java (бинарный код будет исполняться в любой ОС, где есть java-virtual mashine) или .NET Framework (бинарный код будет исполняться в любой ОС, где есть CLR).
Virtual Mashines абстрагируют понятия про которые я говорил (потоки, процессы и т.д.).

metton
Я вроде нормально описывал. Перечитай эту тему заново.
Сегмент указывает на определенный адрес в памяти. К нему добавляем значение смещения.
1111 = 00001111

А значение смещения, если я не ошибаюсь находится в регистре Pi: например адрес начала сегмента находится в начале параграфа т.е. кратен 16, а регистре Pi показывает относительное смещение, ну допустим 2a сложение этих двух значений и есть относительный адрес.

Programmer
Очень интересно. Кое-что из этого я уже знал, кое-что новое.
Но ты, по-моему, немного не о том...
Ведь если ассмблер переводит программу в команды ПРОЦЕССОРА, а не ОС, то и работать должно на одном процессоре независимо от операционки. Так в чём же дело?

metton

Процессор сам по себе ничего делать не будет. ОС должна запустить исполняемый файл и передавать процессору инструкции для выполнения.
Как видишь, всё идет через операционку.

А если работать через БИОС-прерывания и загружать ассемблер в ОЗУ? Тогда ОС не нужна!