Являются ли наборы инструкций и ассемблера одинаковыми?

Мне было интересно, если набор инструкций и ассемблер - это то же самое?

Если нет, то как они отличаются и каковы их отношения?

Спасибо и приветствую!

Ответ 1

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

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

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

0x5C0B

Язык ассемблера будет

add r12,r11

Для этого конкретного процессора. В этом случае это означает, что r11 = r11 + r12. Поэтому я помещаю этот текст, добавление r12, r11 в текстовый файл и использую ассемблер (программу, которая компилирует/собирает язык ассемблера), чтобы собрать его в виде двоичной формы. Как и любой язык программирования, иногда вы создаете объектные файлы, а затем связываете их вместе, иногда вы можете перейти к двоичному. И существует много форм двоичных файлов, которые находятся в ascii и двоичных формах и в целом другом обсуждении.

Теперь, что вы можете сделать в ассемблере, который не является частью набора инструкций? Как они отличаются? Ну для начала вы можете иметь макросы:

.macro add3 arg1, arg2, arg3

    add \arg1,\arg3
    add \arg2,\arg3

.endm


.text

   add3 r10,r11,r12

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

add r10,r12
add r11,r12

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

pop r12

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

mov @r1+,r12

и pop, и mov приводят к операционному коду 0x413C.

Другой пример различий между набором команд и ассемблером, набором команд переключения, выглядит примерно так:

ldr r0,=bob

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

ldr r0,ZZ123
...
ZZ123: .word bob

По существу, в доступном месте от этой инструкции, а не в пути выполнения, создается слово, которое компоновщик заполнит адресом для bob. Команда ldr аналогично ассемблеру или компоновщику будет закодирована с помощью ldr относительной команды pc.

Это приводит к целой категории различий между набором команд и языком ассемблера

call fun

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

Ассемблер может выбрать кодировку этой команды как относительной относительно pc, если функция fun на 40 байт впереди команды вызова, она может закодировать ее с эквивалентом вызова pc + 36 (отнять четыре, потому что pc - одна команда вперед во время выполнения, и это 4-байтная инструкция).

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

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

mov bob,r1

а ассемблер или компоновщик или их комбинация заботится обо всем остальном.

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

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

hang: b hang
  b .
  b 2f
1:
  b 1b
  b 1f
1:
  b 1b
2:

Повесьте: b зависание имеет смысл, ответьте на ярлык, называемый зависанием. По существу ветвь к себе. И как следует из названия, это бесконечный цикл. Но для этого языка ассемблера b. означает ветвь к себе, бесконечный цикл, но мне не приходилось изобретать ярлык, набирать его и вставлять в него. Другим ярлыком является использование чисел b 1b, означает ветвь на 1 назад, ассемблер ищет метку номер 1 за или над инструкцией. B 1f, который не является ветвью к себе, означает ветвь 1 вперед, это совершенно правильный код для этого ассемблера. Он будет смотреть вперед или ниже строки кода для метки номер 1: И вы можете повторно использовать номер 1, как сумасшедший в своей ассемблерной программе для этого ассемблера, экономит на том, чтобы изобретать имена ярлыков для простых коротких ветвей. Второй b 1b переходит во второй 1. и является ветвью к себе.

Важно понимать, что компания, которая создала процессор, определяет набор команд, машинный код или коды операций или какой-либо термин, который они или вы используете для бит и байтов, которые процессор декодирует и выполняет. Очень часто эта компания будет создавать документ с ассемблером для этих инструкций, синтаксис. Часто эта компания будет создавать ассемблерную программу для компиляции/сборки этого языка ассемблера... с использованием этого синтаксиса. Но это не означает, что любой другой человек на планете, который хочет написать ассемблер для этого набора команд, должен использовать этот синтаксис. Это очень заметно с набором инструкций x86. Точно так же любые инструкции psuedo, такие как вышеприведенный поп или синтаксис макроса или другие короткие сокращения, такие как b 1b, должны выполняться с одного ассемблера на другой. И очень часто это не так, вы видите это с помощью ARM, например, универсального символа комментария; не работает с ассемблером gnu, вы должны использовать @вместо этого. Ассемблер ARM использует; (обратите внимание, что я пишу свой ассемблер для рук, @, чтобы сделать его переносным). С gnu-инструментами становится еще хуже, например, вы можете поместить C-языковые вещи вроде #define и /* comment */в ваш ассемблер и использовать компилятор C вместо ассемблера, и он будет работать. Я предпочитаю оставаться таким же чистым, насколько я могу, для максимальной переносимости, но, естественно, вы можете использовать любые функции, предлагаемые инструментом.

Ответ 2

Инструкция set состоит из всех инструкций, которые может выполнить процессор, а сборка - язык программирования, который использует эти инструкции для создания программ.
Другими словами, набор команд - это всего лишь группа байтов, которые может понять процессор, но вы не можете ничего с ними поделать (подумайте, что это буквы букв алфавита), а сборка - это язык, который позволяет объединить эти инструкции (или буквы), чтобы сделать программу (что-то вроде речи).

Ответ 3

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

макросы
способ определения данных
способы определения имен (например, для функций)

Изменить: инструкция (как таковая) будет закодирована в двоичном формате, чтобы процессор мог ее прочитать. Мнемоника - это имя для инструкции. Например, на языке ассемблера я могу написать "mov ax, 1". Соответствующая инструкция для этого будет (в случае x86) кодироваться как B8 00000001 (в шестнадцатеричной форме).

Определение данных, макросов, имен для функций и т.д. не являются фактическими инструкциями. Макрос (как макрос в C и т.д.) Позволяет вам определять имена в процессе сборки. Это может (часто будет) приводить к генерации некоторых инструкций, но они отделены от самого определения макроса. Как и в C, когда вы определяете некоторые данные, которые обычно приводят к записи в объектном файле с указанием некоторого количества пространства для имени X, но напрямую не генерируют никаких инструкций.

Ответ 4

Язык ассемблера - это не просто супермножество набора команд: он способ генерации объектных файлов, символов, информации об отладке, привязки, а также для минимального структурированного программирования даже на этом уровне. (Немного опираться на другие ответы/комментарии здесь)

Макет объекта. Например, разделы: код, данные, только для чтения, отладка, динамическая привязка. Общая директива "org" сообщает ассемблеру расположение инструкций/данных.
Предварительная обработка. Это включает макросы (встроенное расширение, повторение) и иногда структурированное программирование (структура структуры, определение псевдонимов для регистров).
Определение данных. Либо включать файлы, либо определять байты/слова за раз, например ".byte", ".word", ".dw" в зависимости от вашей архитектуры.

Большинство компиляторов C генерируют сборку, которая затем передается ассемблеру для создания объектных файлов. Если вы посмотрите на вывод gcc при запуске с флагом "-S", вы увидите, что большинство из них используется. Если вы включили debug ('-g') и любую динамическую привязку (по умолчанию в эти дни), вы увидите огромную сборку, не предназначенную только для инструкций.

Ответ 5

Компьютер (точнее процессор) может выполнять только вычисления, то есть выполнять арифметические и логические операции.

Единая арифметическая или логическая операция называется командой .

Сбор всех инструкций называется набором команд этого компьютера (точнее процессора).

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

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

Язык - это не что иное, как спецификация на бумаге. Первым языком, разработанным на бумаге, был машинный язык. Его реализация на компьютере возможна только через аппаратное обеспечение (или новейший микрокод техники). Эта реализация называется набором команд. Все остальные языки будут разработаны поверх машинного языка.

Язык машины был трудным для работы, поскольку мы в основном работаем с алфавитами в нашей повседневной жизни. Поэтому было принято решение ввести мнемонический язык под названием "Язык ассемблера" поверх машинного языка. Реализация языка ассемблера была названа Assembler.

[Вы можете задаться вопросом, как был написан первый ассемблер. Первый ассемблер может быть написан или не может быть записан на машинный язык. Я просто не упомянул о понятии бутстрапинга для простоты]

РЕЗЮМЕ:

Язык ассемблера преобразуется в набор команд Assembler. И обе стороны - это разные стороны монеты со слоем абстракции или мнемонического кода между ними. Язык машины - это "бит-кодирование" набора инструкций процессора. Язык ассемблера является "символическим кодированием" набора инструкций процессора.

Ответ 6

Когда вы посмотрите статью Википедии на язык ассемблера, с которым вы связались в своем вопросе, приведен пример, на котором показаны инструкции ассемблера и соответствующие инструкции объектный код. Оба представляют собой разные представления одного и того же: инструкции из набора инструкций процессора. Но только столбец с заголовком "Инструкция (синтаксис AT & T)" содержит ассемблерный язык.

Надеюсь, что это станет более ясным.

Ответ 7

Все в многоуровневой архитектуре с "Строго (в большинстве случаев) и хорошо определенными интерфейсами.

Начало работы с оборудованием

Существует много уровней, пока вы не достигнете процессора.

Слой я означает, что мы начинаем с "физики- > устройств (электроники) → Analog (Amplifier) - > Gates- > Digital Circuits- > Micro-Architecture- > Architecture (ISA, Processor)
Но начать с процессора, он состоит из двух частей (как и большинство встроенных систем).: Железо и софт.
Программная часть, которая называется ISA (архитектура набора инструкций)

Он имеет все инструкции, которые может поддерживать уважаемый процессор. Это означает, что ISA привязана только к одному процессору (такое оборудование, как x86).
Важно, почему этот ISA требуется? То же, что я сказал ранее, это строгий и хорошо определенный интерфейс. Процессор не может выполнять никаких инструкций за пределами ISA [Строго]

Но любой, кто хочет использовать этот процессор, может использовать эти команды из ISA, чтобы выполнить свою работу. [Хорошо определенный интерфейс]

Теперь перейдем к сборке, C, ассемблеру, компилятору....

Многоуровневая архитектура, которую вы знаете, мы ее используем (Layered Arch) в Hardware для реализации одного процессора для вас

Вы можете узнать больше о том, почему эта многоуровневая архитектура. Это позволяет легко справляться с большой проблемой шаг за шагом.
То же самое мы хотим? Какова наша цель?

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

Может ли программист запомнить всю инструкцию для процессора, которые находятся в двоичном формате. И процессор может измениться в следующем приложении от Intel до IBM (теперь это не версия).
- Итак, у нас также есть многоуровневая архитектура [не исправлена].
- 1) Ассемблер - компилятор
- 2) Ассемблер

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

Пример: вы пишете код в C. Процессор не может понять этот код. Он понимает все, что записано в двоичном формате и определяется инструкцией, приведенной в ISA. Но сложно писать (поддерживать | изменять) программу в инструкции в ISA.

1) Таким образом, пользователь записывает код в C. Этот код понимает C-компилятор. Потому что пользователю запрещено использовать только синтаксис, указанный в C. Это означает, что C-компилятор дает стандартный и четко определенный интерфейс для пользователя на одном конце. С другой стороны, он может использовать непосредственно инструкцию ISA или другой интерфейс под названием "Ассемблер".

2) Теперь, если вы используете Assembler, тогда Compiler переведет все C-коды в синтаксис, заданный Assembler. И синтаксис, который Assembler предоставляет компилятору, называется языком ассемблера. Это также хорошо определенный интерфейс, и любой может использовать его для программирования на языке ассемблера. А на другом конце Assembler преобразует весь свой синтаксис (Mnemonics | Directives, те, которые отсутствуют в ISA), в инструкции двоичного кода в ISA.

Вот пример этого перевода.

В C = hello.c
В Сборочном коде = hello.s
В Object Code = hello.obj(No Linking Done: Дополнительная информация)

В этом файле одна строка "Машина: Advanced Micro Devices X86-64" , которая предоставляет информацию о процессоре, соответственно, мы используем ISA и ассемблер. И программист C не знает об этом, он может кодировать код C. Это преимущество "Хорошо определенный интерфейс".

В машинный код = hello.binary(после ссылки: дополнительная информация)

Сравнить просто Смотрите

hello.c(программа C)
hello.asm2bin (Таблица файлов объектов: прямое отображение Мнемоники и двоичная инструкция)
hello.asm2bin_exe (таблица двоичных файлов: большее отображение после привязки)

Вы увидите одну строку в этих файлах "Разборка раздела.." Начиная с того, что делает ассемблер: он собирает инструкцию ISA (бит-образец) из языка ассемблера. Итак, здесь мы видим первую инструкцию ISA и затем разборку Mnemonics.

Все файлы находятся по этой ссылке [Download and Open]

https://www.dropbox.com/sh/v2moak4ztvs5vb7/AABRTxl7KQlqU2EkkMkKssqYa?dl=0

В Linux Вы можете использовать vim, emacs, чтобы открыть эти файлы.
В окнах просто используйте vim или используйте опцию "Open- > Select a program from....." после щелчка правой кнопкой мыши по файлу и выбора текстового редактора по вашему выбору.