Как найти адрес бита

Организация памяти

За последнюю неделю дважды объяснял людям как организована работа с памятью в х86, с целью чтобы не объяснять в третий раз написал эту статью.

И так, чтобы понять организацию памяти от вас потребуется знания некоторых базовых понятий, таких как регистры, стек и тд. Я по ходу попробую объяснить и это на пальцах, но очень кратко потому что это не тема для этой статьи. Итак начнем.

Как известно программист, когда пишет программы работает не с физическим адресом, а только с логическим. И то если он программирует на ассемблере. В том же Си ячейки памяти от программиста уже скрыты указателями, для его же удобства, но если грубо говорить указатель это другое представление логического адреса памяти, а в Java и указателей нет, совсем плохой язык. Однако грамотному программисту не помешают знания о том как организована память хотя бы на общем уровне. Меня вообще очень огорчают программисты, которые не знают как работает машина, обычно это программисты Java и прочие php-парни, с квалификацией ниже плинтуса.

Так ладно, хватит о печальном, переходим к делу.
Рассмотрим адресное пространство программного режима 32 битного процессора (для 64 бит все по аналогии)
Адресное пространство этого режима будет состоять из 2^32 ячеек памяти пронумерованных от 0 и до 2^32-1.
Программист работает с этой памятью, если ему нужно определить переменную, он просто говорит ячейка памяти с адресом таким-то будет содержать такой-то тип данных, при этом сам програмист может и не знать какой номер у этой ячейки он просто напишет что-то вроде:
int data = 10;
компьютер поймет это так: нужно взять какую-то ячейку с номером стопицот и поместить в нее цело число 10. При том про адрес ячейки 18894 вы и не узнаете, он от вас будет скрыт.

Все бы хорошо, но возникает вопрос, а как компьютер ищет эту ячейку памяти, ведь память у нас может быть разная:
3 уровень кэша
2 уровень кэша
1 уровень кэша
основная память
жесткий диск

Это все разные памяти, но компьютер легко находит в какой из них лежит наша переменная int data.
Этот вопрос решается операционной системой совместно с процессором.
Вся дальнейшая статья будет посвящена разбору этого метода.

Архитектура х86 поддерживает стек.

Стек это непрерывная область оперативной памяти организованная по принципу стопки тарелок, вы не можете брать тарелки из середины стопки, можете только брать верхнюю и класть тарелку вы тоже можете только на верх стопки.
В процессоре для работы со стеком организованны специальные машинные коды, ассемблерные мнемоники которых выглядят так:

push operand
помещает операнд в стек

pop operand
изымает из вершины стека значение и помещает его в свой операнд

Стек в памяти растет сверху вниз, это значит что при добавлении значения в него адрес вершины стека уменьшается, а когда вы извлекаете из него, то адрес вершины стека увеличивается.

Теперь кратко рассмотрим что такое регистры.
Это ячейки памяти в самом процессоре. Это самый быстрый и самый дорогой тип памяти, когда процессор совершает какие-то операции со значением или с памятью, он берет эти значения непосредственно из регистров.
В процессоре есть несколько наборов логик, каждая из которых имеет свои машинные коды и свои наборы регистров.
Basic program registers (Основные программные регистры) Эти регистры используются всеми программами с их помощью выполняется обработка целочисленных данных.
Floating Point Unit registers (FPU) Эти регистры работают с данными представленными в формате с плавающей точкой.
Еще есть MMX и XMM registers эти регистры используются тогда, когда вам надо выполнить одну инструкцию над большим количеством операндов.

Рассмотрим подробнее основные программные регистры. К ним относятся восемь 32 битных регистров общего назначения: EAX, EBX, ECX, EDX, EBP, ESI, EDI, ESP
Для того чтобы поместить в регистр данные, или для того чтобы изъять из регистра в ячейку памяти данные используется команда mov:

mov eax, 10
загружает число 10 в регистр eax.

mov data, ebx
копирует число, содержащееся в регистре ebx в ячейку памяти data.

Регистр ESP содержит адрес вершины стека.
Кроме регистров общего назначения, к основным программным регистрам относят шесть 16битных сегментных регистров: CS, DS, SS, ES, FS, GS, EFLAGS, EIP
EFLAGS показывает биты, так называемые флаги, которые отражают состояние процессора или характеризуют ход выполнения предыдущих команд.
В регистре EIP содержится адрес следующей команды, которая будет выполнятся процессором.
Я не буду расписывать регистры FPU, так как они нам не понадобятся. Итак наше небольшое отступление про регистры и стек закончилось переходим обратно к организации памяти.

Как вы помните целью статьи является рассказ про преобразование логической памяти в физическую, на самом деле есть еще промежуточный этап и полная цепочка выглядит так:

Логический адрес —> Линейный (виртуальный)—> Физический

Все линейное адресное пространство разбито на сегменты. Адресное пространство каждого процесса имеет по крайней мере три сегмента:
Сегмент кода. (содержит команды из нашей программы, которые будут исполнятся.)
Сегмент данных. (Содержит данные, то бишь переменные)
Сегмент стека, про который я писал выше.

Линейный адрес вычисляется по формуле:

линейный адрес=Базовый адрес сегмента(на картинке это начало сегмента) + смещение

Сегмент кода

Базовый адрес сегмента кода берется из регистра CS. Значение смещения для сегмента кода берется из регистра EIP, в котором хранится адрес инструкции, после исполнения которой, значение EIP увеличивается на размер этой команды. Если команда занимает 4 байта, то значение EIP увеличивается на 4 байта и будет указывать уже на следующую инструкцию. Все это делается автоматически без участия программиста.
Сегментов кода может быть несколько в нашей памяти. В нашем случае он один.

Сегмент данных

Данные загружаются в регистры DS, ES, FS, GS
Это значит что сегментов данных может быть до 4х. На нашей картинке он один.
Смещение внутри сегмента данных задается как операнд команды. По дефолту используется сегмент на который указывает регистр DS. Для того чтобы войти в другой сегмент надо это непосредственно указать в команде префикса замены сегмента.

Сегмент стека

Используемый сегмент стека задается значением регистра SS.
Смещение внутри этого сегмента представлено регистром ESP, который указывает на вершину стека, как вы помните.
Сегменты в памяти могут друг друга перекрывать, мало того базовый адрес всех сегментов может совпадать например в нуле. Такой вырожденный случай называется линейным представлением памяти. В современных системах, память как правило так организована.

Теперь рассмотрим определение базовых адресов сегмента, я писал что они содержаться в регистрах SS, DS, CS, но это не совсем так, в них содержится некий 16 битный селектор, который указывает на некий дескриптор сегментов, в котором уже хранится необходимый адрес.

Так выглядит селектор, в тринадцати его битах содержится индекс дескриптора в таблице дескрипторов. Не хитро посчитать будет что 2^13 = 8192 это максимальное количество дескрипторов в таблице.
Вообще дескрипторных таблиц бывает два вида GDT и LDT Первая называется глобальная таблица дескрипторов, она в системе всегда только одна, ее начальный адрес, точнее адрес ее нулевого дескриптора хранится в 48 битном системном регистре GDTR. И с момента старта системы не меняется и в свопе не принимает участия.
А вот значения дескрипторов могут меняться. Если в селекторе бит TI равен нулю, тогда процессор просто идет в GDT ищет по индексу нужный дескриптор с помощью которого осуществляет доступ к этому сегменту.
Пока все просто было, но если TI равен 1 тогда это означает что использоваться будет LDT. Таблиц этих много, но использоваться в данный момент будет та селектор которой загружен в системный регистр LDTR, который в отличии от GDTR может меняться.
Индекс селектора указывает на дескриптор, который указывает уже не на базовый адрес сегмента, а на память в котором хранится локальная таблица дескрипторов, точнее ее нулевой элемент. Ну а дальше все так же как и с GDT. Таким образом во время работы локальные таблицы могут создаваться и уничтожаться по мере необходимости. LDT не могут содержать дескрипторы на другие LDT.
Итак мы знаем как процессор добирается до дескриптора, а что содержится в этом дескрипторе посмотрим на картинке:
Дескрипторы состоит из 8 байт.
Биты с 15-39 и 56-63 содержат линейный базовый адрес описываемым данным дескриптором сегмента. Напомню нашу формулу для нахождения линейного адреса:

линейный адрес = базовый адрес + смещение

С помощью такой нехитрой операции процессор может обращаться по нужному адресу линейной памяти.
Рассмотрим другие биты дескриптора, очень важным является Segment Limit или предел, он имеет 20битное значение от 0-15 и 48-51 бит. Предел задает размер сегмента. Для сегментов данных и кода доступными являются все адреса, расположенные в интервале:

[база; база+предел)

В зависимости от 55 G-бита(гранулярити), предел может измеряться в байтах при нулевом значении бита и тогда максимальный предел составит 1 мб, или в значении 1, предел измеряется страницами, каждая из которых равна 4кб. и максимальный размер такого сегмента будет 4Гб.
Для сегмента стека предел будет в интервале:

(база+предел; вершина]

Кстати интересно почему база и предел так рвано располагаются в дескрипторе. Дело в том что процессоры х86 развивались эволюционно и во времена 286х дескрипторы были по 8 бит всего, при этом старшие 2 байта были зарезервированы, ну а в последующих моделях процессоров с увеличением разрядности дескрипторы тоже выросли, но для сохранения обратной совместимости пришлось оставить структуру как есть.
Значение адреса «вершина» зависит от 54го D бита, если он равен 0, тогда вершина равна 0xFFF(64кб-1), если D бит равен 1, тогда вершина равна 0xFFFFFFFF (4Гб-1)
С 41-43 бит кодируется тип сегмента.
000 — сегмент данных, только считывание
001 — сегмент данных, считывание и запись
010 — сегмент стека, только считывание
011 — сегмент стека, считывание и запись
100 — сегмент кода, только выполнение
101- сегмент кода, считывание и выполнение
110 — подчиненный сегмент кода, только выполнение
111 — подчиненный сегмент кода, только выполнение и считывание

44 S бит если равен 1 тогда дескриптор описывает реальный сегмент оперативной памяти, иначе значение S бита равно 0.

Самым важным битом является 47-й P бит присутствия. Если бит равен 1 значит, что сегмент или локальная таблица дескрипторов загружена в оперативку, если этот бит равен 0, тогда это означает что данного сегмента в оперативке нет, он находится на жестком диске, случается прерывание, особый случай работы процессора запускается обработчик особого случая, который загружает нужный сегмент с жесткого диска в память, если P бит равен 0, тогда все поля дескриптора теряют смысл, и становятся свободными для сохранения в них служебной информации. После завершения работы обработчика, P бит устанавливается в значение 1, и производится повторное обращение к дескриптору, сегмент которого находится уже в памяти.

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

Условные обозначения битовых позиций

В вычислениях, нумерация битов — это соглашение, используемое для идентификации позиций бита в двоичном числе или контейнере такого значения. Номер бита начинается с нуля и увеличивается на единицу для каждой последующей битовой позиции.

Содержание

• 1 Младший бит
  • 1.1 Младший бит в цифровой стеганографии
  • 1.2 Младший бит
• 2 Старший бит
  • 2.1 Старший значащий байт
• 3 Пример беззнакового целого
• 4 Первый старший бит против наименее значимого
• 5 Нумерация битов LSB 0
• 6 Нумерация битов MSB 0
• 7 Другое
• 8 Использование
• 9 См. Также
• 10 Ссылки
• 11 Внешние ссылки

Наименьший бит

двоичное представление десятичного числа 149 с выделенным младшим битом. MSB в 8-битном двоичном числе представляет собой десятичное значение 128. LSB представляет значение 1.

В вычислении младший бит (LSB ) является позицией бита в двоичное целое число, дающее значение единиц измерения, то есть определяющее, является ли число четным или нечетным. LSB иногда называют битом младшего разряда или самым правым битом из-за соглашения в позиционной записи о записи менее значимых цифр дальше вправо. Он аналогичен младшей цифре десятичного целого числа, которая является цифрой в позиции единиц (крайняя правая).

Обычно назначают каждый бит — это номер позиции в диапазоне от нуля до N-1, где N — количество битов в используемом двоичном представлении. Обычно это просто показатель степени для соответствующего веса бита в базе 2 (например, в 2..2). Хотя некоторые производители ЦП присваивают номера битов противоположным образом (что не то же самое, что и другой порядок байтов ), сам термин наименее значимый бит остается однозначным как псевдоним для единичного бита.

В более широком смысле наименее значимые биты (множественное число) представляют собой биты числа, ближайшего к младшему разряду и включающего его.

Младшие значащие биты обладают полезным свойством быстрого изменения, если число изменяется даже незначительно. Например, если 1 (двоичный 00000001) добавлен к 3 (двоичный 00000011), результатом будет 4 (двоичный 00000100), а три младших бита изменятся (с 011 на 100). Напротив, три старших бита (MSB) остаются неизменными (от 000 до 000).

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

Наименее значимых бит в цифровой стеганографии

В цифровой стеганографии конфиденциальные сообщения могут быть скрыты путем манипулирования и сохранения информации в младших битах изображения или звукового файла. В контексте изображения, если бы пользователь манипулировал последними двумя битами цвета в пикселе, значение цвета изменилось бы не более чем на ± 3 разряда, что, вероятно, будет неразличимо для человеческого глаза. Пользователь может позже восстановить эту информацию, извлекая младшие биты обработанных пикселей, чтобы восстановить исходное сообщение.

Это позволяет скрывать хранение или передачу цифровой информации.

Младший байт

LSB также может означать младший байт . Значение аналогично приведенному выше: это байт (или октет ) в той позиции многобайтового числа, которая имеет наименьшее потенциальное значение. Если значение наименее значимого байта сокращения не очевидно из контекста, его следует указать явно, чтобы избежать путаницы с наименьшим значащим битом.

Чтобы избежать этой двусмысленности, можно использовать менее сокращенные термины «lsbit» или «lsbyte».

Старший бит

В вычислениях самый старший бит (MSB, также называемый старшим -order bit ) — это позиция бита в двоичном числе, имеющем наибольшее значение. MSB иногда называют старшим битом или крайним левым битом из-за соглашения в позиционной нотации о записи более значимых цифр после осталось.

MSB может также соответствовать знаку бит двоичного числа со знаком. В нотации до единицы и с дополнением до двух «1» означает отрицательное число, а «0» означает положительное число.

Обычно каждому биту присваивается номер позиции в диапазоне от нуля до N-1, где N — количество битов в используемом двоичном представлении. Обычно это просто показатель степени для соответствующего веса бита в базе 2 (например, в 2..2). Хотя некоторые производители ЦП присваивают номера битов противоположным образом (что не то же самое, что различие порядка байтов ), MSB однозначно остается наиболее значимым битом. Это может быть одной из причин, почему термин MSB часто используется вместо числа битов, хотя основная причина, вероятно, состоит в том, что разные представления чисел используют разное количество битов.

В более широком смысле, старшие биты (множественное число) являются битами, ближайшими к MSB и включающими его.

Беззнаковое двоичное представление десятичного числа 149 с выделенным старшим битом. MSB в 8-битном двоичном числе представляет собой десятичное значение 128. LSB представляет собой значение 1.

Старший байт

MSB также может означать «старший значащий байт ». Смысл аналогичен приведенному выше: это байт (или октет ) в той позиции многобайтового числа, которая имеет наибольшее потенциальное значение.

Чтобы избежать этой двусмысленности, часто используются менее сокращенные термины «MSbit » или «MSbyte ».

Пример беззнакового целого числа

В этой таблице показан пример десятичного значения 149 и расположения LSB. В этом конкретном примере позиция значения единицы (десятичная 1 или 0) находится в позиции бита 0 (n = 0). MSB обозначает наиболее значимый бит, а LSB обозначает наименьший значительный бит.

Позиция LSB не зависит от того, как передается позиция бита (некоторые системы сначала передают старший бит, другие сначала передают младший бит), что является скорее вопросом темы Порядок байтов.

Сначала старший / младший бит

Выражения наиболее первый значащий бит и первый младший значащий бит — это указания на порядок последовательности битов в байтах, отправляемых по проводу в протоколе передачи или в потоке (например, аудиопотоке).

Самый старший бит первым означает, что самый старший бит прибудет первым: отсюда, например, шестнадцатеричное число 0x12, 00010010в двоичном представлении прибудет в виде последовательности 0 0 0 1 0 0 1 0.

Сначала младший бит означает, что младший бит прибудет первым: отсюда, например, то же шестнадцатеричное число 0x12, снова 00010010в двоичном представлении, прибудет в виде (обратной) последовательности 0 1 0 0 1 0 0 0.

Нумерация битов LSB 0

LSB 0: контейнер для 8-битного двоичного числа с выделенным младшим значащим битом, которому назначен номер бита 0

Когда нумерация битов начинается с нуля для младшего значащего бита (LSB) схема нумерации называется «LSB 0». Этот метод нумерации битов имеет то преимущество, что для любого беззнакового числа значение числа может быть вычислено с использованием возведения в степень с номером бит и основанием, равным 2.. Следовательно, значение двоичного числа без знака целое равно

∑ i = 0 N — 1 bi ⋅ 2 i { displaystyle sum _ {i = 0} ^ {N-1} b_ {i } cdot 2 ^ {i}}

где b i обозначает значение бита с номером i, а N обозначает общее количество битов.

Нумерация битов MSB 0

MSB 0: контейнер для 8-битного двоичного числа с выделенным старшим битом, которому назначен номер бита 0

Аналогично, когда битовая нумерация начинается с нуля для старшего разряда (MSB), схема нумерации называется «MSB 0».

Следовательно, значение двоичного целого числа без знака равно

∑ i = 0 N — 1 bi ⋅ 2 N — 1 — i { displaystyle sum _ {i = 0} ^ {N-1} b_ {i} cdot 2 ^ {N-1-i}}

Оператор elem другого

ALGOL 68 фактически является «нумерацией MSB 1 бит», поскольку биты пронумерованы слева направо, причем первый бит (биты elem 1) является «старшим значащим битом», а выражение (биты elem ширины битов) дает «младший значащий бит. «. Аналогично, когда биты приводятся (приведение типов) к массиву Boolean ([] bool бит), первый элемент этого массива (биты [lwb биты]) снова является «старшим битом».

Для нумерации MSB 1 значение двоичного целого числа без знака равно

∑ i = 1 N bi ⋅ 2 N — i { displaystyle sum _ {i = 1} ^ {N} b_ { i} cdot 2 ^ {Ni}}

PL / I нумерует BITстроки, начинающиеся с 1 для крайнего левого бита.

Функция Fortran BTESTиспользует нумерацию LSB 0.

Использование

Little-endian CPU обычно используют нумерацию битов «LSB 0», однако оба соглашения о нумерации битов можно увидеть на машинах big-endian. Некоторые архитектуры, такие как SPARC и Motorola 68000, используют нумерацию битов «LSB 0», в то время как S / 390, PowerPC и PA-RISC используют «MSB 0».

Рекомендуемый стиль для документов Request for Comments (RfC) — это нумерация битов «MSB 0».

Нумерация битов обычно прозрачна для программное обеспечение, но некоторые языки программирования, такие как Ada, и языки описания оборудования, такие как VHDL и verilog, позволяют указать соответствующий порядок битов для представления типа данных.

См. Также

• ARINC 429
• Двоичная система счисления
• Представления чисел со знаком
• Дополнение до двух
• Порядок байтов
• Двоичный логарифм
• Последняя единица измерения (ULP)
• Найти первый набор
• MAC-адрес: Обращение к битам

Ссылки

Внешние ссылки

• Номера битов
• Нумерация битов для разных процессоров:
  • Motorola 68000 (разделы «Обработка битов» и «Обратная битовая нумерация»)
  • IBM Cell Broadband Processors («Порядок байтов и бит n umbering «)

Перед изучением команд и регистров процессора 8086, очень важно понять, как он получает доступ к оперативной памяти, чтобы записывать в нее значения и читать их от туда.
Почему именно процессор 8086? Просто потому, что режим совместимости с командами этого процессора есть во всех старших моделях. И начинать изучать язык ассемблера проще с этого процессора.
Процессор 8086, мог работать только в одном режиме адресации памяти. Все следующие модели, начиная с процессора 80286, сохранили режим совместимости с 8086. Этот режим получил название реального режима (Real Address Mode), или R-режима.

Итак, ближе к делу.

Наименьшим адресуемым блоком памяти является байт (8 бит). Каждый байт памяти имеет уникальное местоположение, называемое физическим адресом, по которому в него может записываться и читаться информация. Очевидно, что для того, чтобы получить доступ к ячейке памяти процессору надо знать ее физический адрес. Для доступа к памяти процессор имеет адресную шину, на которой выставляет адрес ячейки памяти к которой ему необходим доступ. Грубо говоря, адресная шина – это «ноги» (pins) процессора на которых он выставляет адрес ячейки в двоичной системе счисления. Например, чтобы адресовать память размером в четыре байта (у каждого байта свой адрес), процессору, было бы, достаточно адресной шины в два бита (две «ноги). Так как, с помощью двух бит можно было бы адресовать 4 ячейки памяти: адрес 00b – 1-ая ячейка (байт), адрес 01b – 2-ая ячейка (байт), адрес 10b – 3-я ячейка (байт), 11 – 4-ая ячейка (байт). Таким образом, очевидно, что чем большую разрядность имеет адресная шина процессора, с тем большим объемом памяти он может работать.
Процессор 8086 имел 20 битную адресную шину. Что позволяло адресовать 1048576 байт (2²⁰) памяти или округленно 1 Мбайт. Проблема состояла в том, что процессор 8086 имел 16 битную архитектуру. То есть все его регистры были 16 битными. А с помощью 16 бит можно адресовать только 65536 (2¹⁶) байт памяти или округленно 64 Кбайт. Тогда каким же образом процессор 8086 адресовал 1 Мбайт памяти?
Решением стала сегментная адресация памяти. С помощью этого метода физический адрес конкретного байта памяти может логически определятся двумя 16-разрядными значениями. Для того, чтобы с помощью 16-разрядных регистров можно было обращаться в любую точку 20-разрядного адресного пространства, введён двухкомпонентный логический адрес из двух 16-разрядных компонент:

Segment (сегмент) : Offset (смещение)
Пример: 13DF:0100

Где Segment – адрес сегмента, а Offset – смещение от начала этого сегмента.

Но постойте! Два 16-разрядных регистра дают 32 разряда. Как же из этого получается 20 битный адрес? Давайте разбираться где тут собака порылась.

Для определения начала сегментов памяти процессор 8086 использует четыре 16-битных сегментных регистра (CS, DS, SS, ES). Смещение внутри сегмента выбирается из регистров-указателей SP, BP, SI, DI или регистра IP (указателя команд — Instructions Pointer). Для получения 20-битного физического адреса, процессор размещает на адресной шине значение сегментного регистра и сдвигает его влево на четыре бита, заполняя младшие четыре бита адресной шины нулями (умножение на десятичное 16 или шестнадцатеричное 10 ), затем к этому значению прибавляется смещение и адрес сформирован.

Исходя из этого получается что границы сегментов (16-битное значение + 4 нулевых бита) располагаются через каждые 16 байт физических адресов. 4 битами можно адресовать 16 (байт) ячеек памяти, каждая из которых как мы помним содержит один байт. Каждый из этих 16-байтовых фрагментов называется параграфом. 16-разрядные сегментные регистры могут адресовать 65536 (2¹⁶) параграфов (границ сегментов). А параграф, как уже говорилось, это 16 байт. 65536(параграфов) умножаем 16(байт) получаем 1048576 байт или округленно 1 Мбайт. Хотя и тут не все гладко :). Здесь порылась вторая собака. Откапывать ее будет чуть позже.

Ниже приведен вывод регистров и сегмента кода в программе debug.exe, чтобы можно было все это наглядно увидеть.

-r
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=13DF ES=13DF SS=13DF CS=13DF IP=0100 NV UP EI PL NZ NA PO NC
13DF:0100 0000 ADD [BX+SI],AL DS:0000=CD
-d cs:100
13DF:0100 00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00 …………….
13DF:0110 00 00 00 00 00 00 00 00-00 00 00 00 34 00 CE 13 …………4…

Например, в сегментном регистре (CS -выделен ярким желтым цветом) хранится значение 13DFh, при умножении его на 10h получаем 13DF0h. Стоит обратить внимание, что младшая шестнадцатеричная цифра в адресе каждого сегмента всегда равна 0. То есть адрес любого сегмента всегда кратен 16 десятичному (10h). Поскольку последняя цифра в адресе сегмента всегда равна 0, то ее можно не хранить. В действительности 8086 вместо умножения на 16 использовал содержимое регистра так, как если бы оно имело четыре дополнительных нулевых бита (см. картинку).

Максимальный размер сегмента определяется теми же 16 битами регистра, в котором хранится смещение. Следовательно, максимальный размер сегмента может быть 65536 байт (2¹⁶). Минимальный – 16 байт (размер параграфа). Таким образом, сегменты – это виртуальные умозрительные части с максимальным объемом 64 Кбайт каждая.

Теперь будем откапывать вторую собаку. Возьмем максимальное значение, которое может адресовать сегментный регистр FFFF, применим к нему сдвиг влево на 4 бита, получим FFFF0h (1048560d). Теперь прибавим к этому числу максимальное значение которое может хранится в регистре смещения – FFFF. Таким образом, FFFF0+FFFF= 10FFEF (1114095d). И что это такое? Мы же явно вышли за пределы 1048576 байт памяти. 20 битная адресная шина позволяет максимально адресовать 1048576 байт памяти с адресами от 00000h до FFFFFh. При адресации же памяти свыше 100000h и до 10FFEFh происходил «заворот» — старший единичный бит адреса игнорировался и доступ шёл к 64 килобайтам в начальных адресах (0000h…FFEFh).

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

Факты о «свинье»:
* Нет никаких препятствий для обращения к физически не существующей памяти.
* При обращении к несуществующей памяти результат непредсказуем (все зависит от разработчика материнской платы и другого аппаратного обеспечения компьютера).
* Программа может обращаться к любому сегменту как для считывания, так и для записи данных и команд.

И еще немного правды о сегментах:
* Сегменты физически не выделены в памяти. Сегменты — это логические окна, через которые программы просматривают области памяти удобными, в 64 Кбайт порциями.
* Размеры сегментов могут изменятся от 16 байт до 64 Кбайт (65536 байт).
* Сегменты не обязательно в памяти располагаются один за другим. Хотя такое бывает достаточно часто.
* Сегменты могут перекрываться один другим; поэтому один и тот же физический байт памяти может иметь различные логические адреса, определяемые разными, но при этом эквивалентными парами сегмент-смещение. Например, пары логических адресов 0000:0010 и 0001:0000 указывают на один и тот же физический адрес ячейки памяти — 0010h.
* Назначением базовых адресов сегментов занимается операционная система, а внутри каждого сегмента адреса формируются программой.
* сегментная организация обеспечивает создание позиционно – независимых или динамически перемещаемых в памяти программ.

Более подробный материал по теме можно взять здесь.

Соседние файлы в папке WinRAR archive

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #