3.2. Стеки - А. Ю. Каргашина и А. С. Миркотан под редакцией > Ю. М. Баяковского

3.2. Стеки
Как уже говорилось в §3.1, стек есть совокупность элементов, которые заносятся в память таким способом, что записанный последним оказывается самым доступным. Стеки чрезвычайно удобны для хранения данных в вычислительной машине. Частные от деления в программе печати, а также (как мы уже видели) начальные адреса последовательно вызывающих одна другую подпрограмм являются лишь двумя из многочисленных примеров обработки информации по принципу LIFO: «последним пришел — первым обслужен» (Last In, First Out). За годы своего применения стеки получали различные названия. Часто их называют магазинами по аналогии с устройством автоматов, которые можно встретить в закусочных13. Каждая новая тарелка «вталкивается» сверху. Чтобы взять тарелку, нужно «вытолкнуть самую верхнюю с вершины». При такой интерпретации может возникнуть превратное представление, что весь расположенный в памяти машины массив информации сдвигается, когда к нему добавляется новый элемент или удаляется элемент, записанный последним.

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


^ Указатель стека. В системе PDP-11 стек представляет собой область памяти, отведенную программистом или операционной системой, для хранения информации по принципу LIFO. Данные, хранящиеся в стеке, выглядят точно так же, как и любые другие данные, и, более того, доступны для выборки обычным способом. Однако, чтобы блок памяти действительно стал стеком, в программе должен еще содержаться указатель его вершины. Занесение на вершину стека или снятие с нее осуществляется путем косвенной адресации через указатель стека.

Допустим, что в качестве указателя в программе используется регистр R1 и что для стека отводятся ячейки с 1000 по 1400 (не включая последнюю). Это означает лишь то, что программист будет стараться избегать обращаться к этим ячейкам иначе как через R1. Перед началом вычислений стек пуст. Программа должна начинаться с установки указателя стека таким образом, чтобы данные заносились в него, начиная с ячейки, считающейся его дном.



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

Поскольку элементы заносятся в ячейки стека с последовательно убывающими адресами, здесь напрашивается автодекрементный способ адресации. Итак, сначала мы должны поставить команду MOV #1400,R1, после чего содержимое ячейки MEM будет занесено в стек так

MOV MEM,-(R1)

а верхний элемент будет снят со стека и занесен в ячейку WRD командой

MOV (R1)+,WRD

В обоих случаях регистр ^ R1 продолжает указывать на вершину стека.

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

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

.BLKW 400

START: MOV #1400,R1

Однако, чтобы завести стек, программе совсем не обязательно знать свой начальный адрес. Цель команды ^ MOV состоит в том, чтобы занести в R1 адрес ее же первого слова. Язык ассемблера системы PDP-11 воспринимает символ . (точка) как адрес первого слова той команды, в которой он используется. Поэтому можно заменить MOV командой

START: MOV #.,R1

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

TST (R0)+

BEQ .-2

будут повторяться до тех пор, пока не встретится нулевой элемент. ^ Мы настоятельно рекомендуем избегать подобной записи. Даже удобствами ни в коей мере нельзя оправдать опасность ошибки в вычислении величины смещения, которая особенно вероятна из-за различных длин команд в машине PDP-11. А поскольку допускаются локальные метки вида n$, использование в таких ситуациях символа . вообще не может иметь никаких реальных выгод.

В то же время арифметические средства ассемблера удобно использовать в выражениях типа ^ MEM+2 (адрес слова, следующего за MEM), MEM—2 и т. п. Как вы считаете, какие проблемы могут возникнуть, если в качестве адреса указать MEM+WRD или MEM—WRD?

Ассемблер также может выполнять операции умножения (обозначается *) и деления (обозначается /), отбрасывая в последнем случае остаток. Учтите, однако, что вычисления арифметических выражений производятся ассемблером слева направо без учета привычного приоритета операций. Так, результат вычисления выражения 1+2*2 равен не 5, а 6. Для задания иного порядка вычислений можно использовать угловые скобки .


^ Вычисление арифметических выражений. Давайте разберемся, как в ассемблере производится вычисление арифметических выражений. Поставим перед собой такую задачу: написать программу, которая читает арифметическое выражение с терминала и печатает результат его вычисления. Выражение будет представлять собой последовательность положительных чисел, чередующихся со знаками операций. Начинаться и заканчиваться оно должно числом. Вдобавок могут встречаться пары круглых скобок, причем открывающие скобки должны непосредственно предшествовать числу, а закрывающие следовать сразу после числа. Так, 3*(7—4)+1—(6—3) подобного рода выражение. Заметьте, что операцию умножения мы скобками не выделяем. Не забывайте также, что в выражении, включенном в написанную на языке ассемблера программу, должны применяться угловые, а не круглые скобки.

В нашей программе будет использоваться стек, а в качестве указателя стека — ^ R1. Мы начнем с чтения текста в коде ASCII и записи его в блок памяти, причем R2 будет указывать на первое слово блока. Здесь потребуются некоторые вспомогательные подпрограммы, которые вы можете написать сами. В подпрограмме NUM будет формироваться число, первая цифра которого находится в (R2). При возврате из NUM регистр R2 должен указывать на ячейку, следующую сразу за последней цифрой числа, а результат подпрограмма NUM заносит в стек. Подпрограмма OP должна заносить код обнаруженной по адресу (R2) арифметической операции (код ASCII) на вершину стека и изменять R2 так, чтобы он указывал на следующую ячейку. В главной программе нужно, естественно, обеспечить, чтобы при вызове NUM регистр R2 указывал на первую цифру числа, а при вызове OP — на знак арифметической операции.

Необходимо также написать подпрограмму CALC, которая выполняет вычисления, когда в стеке возникает ситуация такого вида:

число

←R1

операция




число




Подпрограмма должна выполнить требуемое действие, результат будет занесен в стек на место нижнего числа, а сами числа удалены из стека. Например, при операции + подпрограмма CALC выполнит следующее:

TST (R1)+,(R1)+

ADD -4(R1),(R1)

Обратите внимание на манипуляции со стеком! Заранее, конечно, неизвестно, какая операция поступит на вход подпрограммы ^ CALC. Поэтому она должна начинаться с проверки содержимого ячейки 2(R1) и дальше осуществлять переход на процедуру, выполняющую соответствующие вычисления.


УПPАЖНЕНИЕ. Напишите эти вспомогательные подпрограммы.


Ядром нашей программы будет подпрограмма ^ EVAL для вычисления значения выражения. Главная программа будет считывать выражение с терминала в блок памяти по указателю R2, вызывать подпрограмму EVAL, производить вывод на печать и осуществлять выход. Фрагмент подпрограммы вывода должен напечатать содержимое ячейки, находящейся на дне стека.

Прежде всего рассмотрим, как написать подпрограмму EVAL, чтобы она могла работать с выражениями без круглых скобок. Мы считываем первое число и заносим его в стек. Если следующий символ есть , то вычислений не требуется, и мы возвращаемся в главную программу. В противном случае в стек заносится знак операции и следующее число. Затем вызывается подпрограмма CALC, чтобы выполнить требуемые вычисления, результат которых останется в стеке. Если далее следует символ , то возвращаемся в главную программу. Иначе следующий знак операции и число заносятся в стек, и процесс повторяется.

EVAL: JSR R5,NUM

CMP #15,(R2)

BNE 1$

RTS R5

1$ JSR R5,OP

JSR R5,NUM

JSR R5,CALC

CMP #15,(R2)

BNE 1$

RTS R5


УПPАЖНЕНИЯ. 1. Сколько места под стек нужно будет отвести для такой программы?

2. Нарисуйте блок-схему программы.

3. Напишите программу и подходящим образом (где это нужно) ее прокомментируйте.


Попробуем разобраться в том, как работает наша подпрограмма. Допустим, мы набрали на терминале 1+2*2. Подпрограмма ^ EVAL начинается с вызова подпрограммы NUM, т.е. с засылки числа 1 в стек. Поскольку следующий символ не , происходит переход на метку 1$ и занесение знака +, а также числа 2 в стек. Теперь стек выглядит так:

2

←R1

+




1




Далее вызывается подпрограмма CALC, которая оставляет стек в таком виде:

3

←R1

Процесс занесения знака операции и числа повторяется, что приводит к

2

←R1

*




3




а после подпрограммы CALC в стеке остается

6

←R1

Следующий символ есть . Команда ^ RTS R5 возвращает нас в главную программу. Теперь печатается элемент стека (т.е. число 6) и происходит выход из программы.


УПPАЖНЕНИЕ: Измените программу так, чтобы она могла воспринимать выражения, в которых перед первым числом или после открывающей скобки стоит знак — (унарный минус в отличие от бинарного, который является знаком операции и ставится между числами).


^ Рекурсивные подпрограммы. Возможности нашей программы существенно расширятся, если она будет обрабатывать выражения, содержащие скобки. Посмотрим, как вычисляется, например, такое выражение: 3*(7—5). Сначала все происходит так же, как и в подпрограмме EVAL, поскольку выражение начинается с числа 3, за которым следует операция умножения. Затем встречается открывающая скобка, и мы тут же откладываем вычисление 3* и начинаем новое. Оно состоит в выполнении действия 7—5. Чтобы его выполнить, мы снова проходим через подпрограмму EVAL, но на этот раз начальным числом становится 7. Подпрограмма EVAL заканчивает это подчиненное вычисление, когда встречается закрывающая скобка. Во время работы она вызывает подпрограмму CALC, результатом выполнения которой является число 2. Теперь можно продолжить отложенное вычисление, зная, что оно состоит в умножении 3*2. Для этого прежняя подпрограмма EVAL вызывает CALC и потом возвращается в главную программу.

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

Наступил подходящий момент для того, чтобы вновь обратиться к §3.1 и проверить, не препятствует ли механизм работы команд JSR—RTS возможности обращения из подпрограммы к самой себе. Вам следует просмотреть рассуждения, касающиеся рис 3.2, и убедиться в том, что, даже если подпрограммы SUB1, SUB2 и SUB3 заменить одной подпрограммой SUB, адреса возврата останутся правильными. Конечно, при обращении рекурсивной процедуры к самой себе должны быть соблюдены некоторые условия — иначе она передаст управление неизвестно куда и никогда не возвратится назад.

Рекурсивные подпрограммы наиболее ярко демонстрируют опасность, общую для работы с любыми подпрограммами: необходимо заботиться о том, чтобы вызывающая подпрограмма не портила ячейки, которые будет использовать подпрограмма вызываемая. Посмотрите, например, что произойдет, если окончательный результат работы подпрограммы EVAL будет помещен в нулевой регистр, а она снова вызовет саму себя. Однако то, как она была написана нами, позволяет вносить дальнейшие усовершенствования и в то же время избегать подобной опасности (поскольку для хранения промежуточных данных и конечного результата в ней используется стек, то при каждом рекурсивном вызове отводятся новые ячейки памяти).

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

сохранилось и в будущем, то для вызывающей программы вызов подпрограммы EVAL произведет действие, аналогичное вызову подпрограммы NUM: в стеке появится число. Значение этого вывода состоит в том, что он позволяет сохранить очень, простую структуру подпрограммы EVAL. Блок-схема последней представлена на рис. 3.3.



Рис. 3.3. Блок-схема для вычисления арифметических выражений.


Условные переходы, как и ранее, относятся к следующему обрабатываемому символу.


УПPАЖНЕНИЕ. До сих пор мы не уделяли достаточного внимания условиям возврата из новой версии подпрограммы ^ EVAL, если даже пока не учитывать, что следующий после возврата из CALC символ может оказаться закрывающей скобкой. Ограничивает ли это круг выражений, с которыми она может работать? В частности, может ли программа в том виде, как она представлена на рис. 3.3, вычислить выражения:

а) (1+2)*3?

б) 1+((2+3)+4)?

в) 1+(2*(3+4))?

Как нужно изменить структуру подпрограммы, чтобы снять эти ограничения?


Теперь мы должны написать подпрограмму EVAL так, чтобы привести ее в соответствие с блок-схемой. Текст такой программы приведен на рис. 3.4.


EVAL: JSR R5,NUM

CMP #15,(R2)

BNE 1$

RTS R5

1$: JSR R5,OP

CMP #'(,(R2)

BNE 2$

TST (R2)+ ; сдвиг последней (

JSR R5,EVAL

BR 3$

2$: JSR R5,NUM

3$: JSR R5,CALC

CMP #'),(R2)+ ; сдвиг последней )

BEQ 4$

CMP #15,-(R2) ; не ), поэтому выход

BNE 1$

4$: RTS R5

Рис. 3.4. Рекурсивная подпрограмма вычисления арифметических выражений.


Проследим за ее работой на примере выражения 3*(7—4)—(1—(6—3)). На рис. 3.5 представлены состояния стека на различных этапах вычислений. Говоря о том или ином этапе, мы будем ссылаться на соответствующую букву внизу рисунка.



Рис. 3.5. Состояния стека в процессе вычисления выражения 3х(7-4)-(1-(6-3)).


Подпрограмма EVAL начинает свою работу с засылки в стек числа 3 и символа *, что соответствует этапу а. После этого ей попадается символ (, в результате чего, сдвинув сначала на одну позицию указатель R2, она вызывает саму себя. При этом вызове в стек последовательно заносятся символы 7, — и 4 (этап b), затем происходит обращение к подпрограмме CALC, которая вычисляет разность 7—4 и оставляет стек в состоянии c. Взгляните на свою подпрограмму CALC и убедитесь в том, что именно в этом и состоит ее функция. Подпрограмма EVAL встречает теперь символ ) и осуществляет возврат. Обратите внимание на то, как в командах CMP, стоящих после метки 3$, применяется автоматическое изменение содержимого регистра, позволяющее на выходе обеспечить, чтобы R2 не указывал на открывающую скобку и в то же время чтобы не был пропущен символ . Возврат происходит на команду, следующую после JSR R5,EVAL в подпрограмме EVAL,— ведь выполнение «главной» EVAL еще не закончено. И из листинга программы, и из блок-схемы ясно, что теперь EVAL вызывает CALC, которая выполняет операцию 3*3 и оставляет стек в состоянии d (восьмеричное представление). В «главной» подпрограмме EVAL теперь управление передается обратно на метку 1$ и заносится в стек символ —, что соответствует этапу e. Потом, встретив открывающую скобку, она вызывает себя. Эта «вспомогательная» EVAL заносит 1 и — в стек (этап f), наталкивается на новую открывающую скобку и снова обращается к самой себе. Эта «еще более вспомогательная» EVAL заносит в стек 6, — и 3, что соответствует этапу g; вызывает CALC, которая оставляет стек в состоянии h, и возвращается на строчку в подпрограмме EVAL, следующую за командой JSR R5,EVAL. Адреса возврата из подпрограмм хранятся во внешнем по отношению к ним стеке, и этот выход осуществляется в предыдущую («вспомогательную») EVAL. «Вспомогательная» EVAL вызывает теперь CALC, после выполнения которой стек находится в состоянии i; затем, встретив закрывающую скобку, она передает управление главной подпрограмме EVAL. Последняя вызывает CALC, после чего стек переходит в состояние j, и по завершающему символу  осуществляется возврат в главную программу, которая теперь печатает результат.


УПPАЖНЕНИЯ. 1. Напишите полностью всю программу.

2. Измените ее так, чтобы выражение могло начинаться с открывающей скобки, о чем уже упоминалось выше.

3. Измените программу, чтобы в выражении можно было употреблять унарный минус.

4*. Измените программу так, чтобы (как это обычно принято) до тех пор, пока с помощью скобок не будет указано противное, приоритет операций * и / был бы выше приоритета операций + и —.

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


^ Системный стек. Из описания работы команд JSR и RTS вы уже, наверное, догадались, что аппаратура системы PDP-11 пользуется стеком, причем в качестве его указателя всегда берется регистр номер 6. Этот регистр называется аппаратным указателем стека, и ему, как правило, дается имя SP. В программе обычно следует объявить

SP=%6

Теперь мы знаем, что команда

JSR R5,SUB

эквивалентна последовательности

MOV R5,-(SP)

MOV "return PC",R5

MOV #SUB,PC

в то время как RTS R5 — последовательности

MOV R5,PC

MOV (SP)+,R5

Помните, однако, что множество действий этих команд выполняется аппаратурой как одна операция. Их нельзя «странслировать» в эквивалентные им последовательности, и последние нужно рассматривать лишь как описание, но не как определение.

Любая операционная система отводит место под стек и устанавливает SP. Обычно системный стек начинается с ячейки 776, и отводимое под него пространство простирается до ячейки 400. Программы пользователя загружаются сразу после области стека, начиная с ячейки 1000.

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

MOV #.,SP

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

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


УПPАЖНЕНИЕ. Измените программу EVAL так, чтобы в ней вместо R1 в качестве указателя стека использовался SP. Проанализируйте рассмотренный выше алгоритм вычисления выражения и приготовьте таблицу состояний стека, подобную приведенной на рис. 3.5. Как вы считаете, улучшилась ли от этого программа?


Проницательный читатель может резонно спросить, так уж ли нам необходим особый регистр для осуществления обращений к подпрограммам, если мы решили экономить на использовании регистров? Почему бы при вызове подпрограммы не занести адрес возврата в стек, а при выходе из нее не взять его оттуда? Такое решение действительно возможно, и достигается оно путем обращения к PC как к регистру связи при вызове подпрограммы

JSR PC,SUB

и при выходе из нее

RTS PC

В §3.4 мы покажем преимущества заведения особого регистра связи.


Сопрограммы. Эта тема слишком сложна, чтобы обстоятельно здесь ею заниматься, но реализация сопрограмм в PDP-11 настолько изящна, что о ней нельзя умолчать.

Мы видели, что если в команде ^ JSR в качестве регистра связи выступает счетчик команд, то она загружает исполнительный адрес в PC, а адрес возврата в системный стек. Интересная форма команды получается, если адрес программы, которой должно быть передано управление, сам был занесен в стек. Заметим, что в этом случае требуемый исполнительный адрес есть не (SP) (т.е. ячейка в системном стеке), а ячейка, на которую указывает (SP). Поэтому управление передается командой

JSR PC,@(SP)

Это приводит к засылке адреса возврата в стек поверх того адреса, на который только что было передано управление. Нет, однако, никакой причины, ради которой последний должен оставаться в стеке. Лучше, прежде чем заносить текущее значение PC, его оттуда убрать. Это достигается таким видоизменением команды:

JSR PC,@(SP) +

что приводит к обмену содержимого PC и верхней ячейки стека. (Какой порядок операций внутри команды JSR при этом подразумевается?) Из симметрии следует, что программа, которой было передано управление, может возвратить его назад точно такой же командой, после чего в стеке будет содержаться адрес следующей за ней ячейки. Новая команда JSR PC,@(SP)+ передаст управление именно на эту ячейку.

У нас сложилась ситуация, когда две программы могут поочередно передавать управление друг другу. Такие программы называются сопрограммами, что подчеркивает факт их кооперации, основанной на равноправии, а не на подчинении, как в подпрограммах.

Сопрограммы оказываются незаменимыми, когда программа разделяется на два основных задания, которые должны быть между собой скоординированы, но при этом их слишком тесная взаимосвязь ведет к излишним усложнениям. Программа, с задания которой начинается работа, занесет адрес второй ячейки в стек. В дальнейшем, как только одной программе требуется помощь другой, она вызывает ее командой JSR PC,@(SP)+ Системные программы часто выполняют столь переплетенные функции, что в них приходится использовать сопрограммы. На рис. 3.6 показана упрощенная схема взаимодействия двух процессов — чтения и интерпретации, которые протекают внутри ассемблера, когда он расшифровывает мнемонику очередной команды.



Рис. 3.6. Передача управления между сопрограммами в ассемблере.


Счетчик адресов. Точка . представляет собой символ для обозначения счетчика адресов, который заведен внутри программы ассемблера и увеличивается в процессе трансляции программы.

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

MOV #.,SP

Это действие, однако, бессмысленно, если перед программой не зарезервировано место в памяти. Большинство операционных систем гарантирует отведение под стек определенного количества памяти, загружая программу с тысячного адреса. Если требуется еще больший, чем автоматически предоставляемый системой, объем памяти, то в начале программы можно поставить директиву .BLKW и тем самым увеличить начальный адрес, т.е. адрес первой выполняемой команды. Директива .BLKW заставляет транслятор увеличить счетчик адресов на удвоенную величину параметра (счетчик адресов подсчитывает байты). Альтернативой директиве .BLKW является директива .BLKB, служащая для резервирования блока байтов. Поэтому команды

.BLKW 40

.BLKB 100

эквивалентны друг другу. Того же результата можно достичь другим способом — изменением значения счетчика адресов оператором прямого присваивания:

.=.+100

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

.=1400

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

Все же можно дать указание ассемблеру производить трансляцию в абсолютных адресах директивой ^ .ASECT. После нее точка . также воспринимается в абсолютном смысле и может быть приравнена любому требуемому адресу: .=1400.

В следующих параграфах мы увидим, что при программировании может понадобиться заполнять ячейки, расположенные в начале памяти. Они служат для выполнения различных аппаратных функций. Пусть, к примеру, двенадцатая ячейка должна содержать код 340, а в остальном программа должна остаться обычной перемещаемой программой. Вместо того чтобы устанавливать значение этой ячейки в процессе исполнения (каким образом?), оно может быть занесено во время трансляции:

.ASECT

.=12

.WORD 340

Потом директивой .CSECT можем указать ассемблеру, чтобы все последующие команды воспринимались им как перемещаемые, и продолжить нашу программу.

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


УПPАЖНЕНИЯ. 1. Какой способ заполнения ячейки 12 вам больше нравится?

2. Что делает команда MOV .,SP?

3. Что общего между . и PC?

4. Пусть команда MOV #.,SP загружается, начиная с ячейки 1400. Каким будет код этой команды? Какой код для нее сформировал ассемблер? Зависят ли ваши ответы от того, где расположена команда: внутри абсолютной или относительной секции?


9504199850959482.html
9504239886799133.html
9504343383181252.html
9504555530155842.html
9504597432458721.html