Java байткод «Hello world»
На хабре уже есть статья про java байткод. Я решил ее немного дополнить и в меру сил развить тему. Мне кажется довольно логичным разобрать простейшее приложение на Java. А что может быть проще «Hello world»?
Для своего эксперимента я создал директорию src, куда в папку hello положил файл App.java:
package hello; public class App < public static void main(String[] args) < System.out.println("Hello world!"); >> Скопилируем файл командой:
javac src/hello/App.java -d classes/
На выходе в папке classes у меня появился файл App.class Для начала сравним размеры java и class файлов.
App.java 139B
App.class 418B
Это было неожиданно. Мне почему-то казалось, что скомпилированный файл должен быть меньше. Попытаюсь открыть class файл:
hexdump App.class
0000000 ca fe ba be 00 00 00 34 00 1d 0a 00 06 00 0f 09 0000010 00 10 00 11 08 00 12 0a 00 13 00 14 07 00 15 07 0000020 00 16 01 00 06 3c 69 6e 69 74 3e 01 00 03 28 29 0000030 56 01 00 04 43 6f 64 65 01 00 0f 4c 69 6e 65 4e 0000040 75 6d 62 65 72 54 61 62 6c 65 01 00 04 6d 61 69 0000050 6e 01 00 16 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 0000060 2f 53 74 72 69 6e 67 3b 29 56 01 00 0a 53 6f 75 0000070 72 63 65 46 69 6c 65 01 00 08 41 70 70 2e 6a 61 0000080 76 61 0c 00 07 00 08 07 00 17 0c 00 18 00 19 01 0000090 00 0c 48 65 6c 6c 6f 20 77 6f 72 6c 64 21 07 00 00000a0 1a 0c 00 1b 00 1c 01 00 09 68 65 6c 6c 6f 2f 41 00000b0 70 70 01 00 10 6a 61 76 61 2f 6c 61 6e 67 2f 4f 00000c0 62 6a 65 63 74 01 00 10 6a 61 76 61 2f 6c 61 6e 00000d0 67 2f 53 79 73 74 65 6d 01 00 03 6f 75 74 01 00 00000e0 15 4c 6a 61 76 61 2f 69 6f 2f 50 72 69 6e 74 53 00000f0 74 72 65 61 6d 3b 01 00 13 6a 61 76 61 2f 69 6f 0000100 2f 50 72 69 6e 74 53 74 72 65 61 6d 01 00 07 70 0000110 72 69 6e 74 6c 6e 01 00 15 28 4c 6a 61 76 61 2f 0000120 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 29 56 00 21 0000130 00 05 00 06 00 00 00 00 00 02 00 01 00 07 00 08 0000140 00 01 00 09 00 00 00 1d 00 01 00 01 00 00 00 05 0000150 2a b7 00 01 b1 00 00 00 01 00 0a 00 00 00 06 00 0000160 01 00 00 00 03 00 09 00 0b 00 0c 00 01 00 09 00 0000170 00 00 25 00 02 00 01 00 00 00 09 b2 00 02 12 03 0000180 b6 00 04 b1 00 00 00 01 00 0a 00 00 00 0a 00 02 0000190 00 00 00 06 00 08 00 07 00 01 00 0d 00 00 00 02 00001a0 00 0e 00001a2 Довольно непривычный вид для Java кода. Попробуем с помощью описание формата class файлов понять, что здесь закодировано.
ca fe ba be Это 4 байта для magic, который определяет формат файла.
00 00 minor version — Минорная версия как следует из названия
00 34 major version — 2 байта под мажорную версию.
Сочетание minor и major version говорит о том, что я компилировал этот код с помощью J2SE 8.
00 1d Эти два байта представляют constant_pool_count и отвечают за размер constant_pool. В моем случае count равен 29, а размер пула, соответственно 28. Дальше идут элементы вида:
cp_info u1 tag; // 1 байт на тег
u1 info[]; // массив с описанием
>
Рассмотрим элементы в constant_pool.
1-ый элемент:
Этот тег соответствует CONSTANT_Methodref, а значит дальше должно быть описание:
CONSTANT_Methodref_info u1 tag;
u2 class_index;
u2 name_and_type_index;
>
соответственно:
00 06 class_index, указывает на 6 элемент в constant_pool
00 0f name_and_type_index, указывает на 15 элемент в constant_pool
Пока не понятно, на какой метод указывает эта ссылка и мы идем дальше:
2-ой элемент:
Это CONSTANT_Fieldref, а значит дальше ищем:
CONSTANT_Fieldref_info u1 tag;
u2 class_index;
u2 name_and_type_index;
>
И тут все очень похоже на предыдущий элемент, хотя не понятно что это за поле, в своем классе я вроде ничего такого не объявлял.
00 10 class_index в 16 элементе
00 11 name_and_type_index в 17 элементе
tag для CONSTANT_String
CONSTANT_String_info
получаем, что самое интересное лежит в 18 элементе:
00 12 Tag соответствующий ссылке на метод:
класс которого описан в 19 элементе
00 13 a название и тип в 20 элементе:
00 14 5-ый элемент:
Tag для CONSTANT_Class
название, которого в 21 элементе
00 15 6-ой элемент:
Cнова CONSTANT_Class
c названием в 22 элементе
00 16 Как мы помним 1-ый элемент constant_pool относится к этому классу.
7-ой элемент:
tag, CONSTANT_Utf8, первая строчка
Она должна соответствовать:
CONSTANT_Utf8_info u1 tag;
u2 length;
u1 bytes[length];
>
Тогда длина нашей строчки 6 байт:
00 06 А значение «»:
3c 69 6e 69 74 3e Это особое название, так помечаются конструкторы.
8-ой элемент:
строчка длины 3 — «()V»:
00 03 28 29 56 Это описание нашего конструктора без параметров, который был упомянут в седьмом элементе.
9-ый элемент:
CONSTANT_Utf8
00 04 43 6f 64 65 10-ый элемент:
Строка LineNumberTable
01 00 0f 4c 69 6e 65 4e 75 6d 62 65 72 54 61 62 6c 65 11-ый элемент
«main»:
01 00 04 6d 61 69 6e 12-ый элемент
«([Ljava/lang/String;)V»
01 00 16 28 5b 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 29 56 13-ый элемент
«SourceFile»
01 00 0a 53 6f 75 72 63 65 46 69 6c 65 14-ый элемент
«App.java»:
01 00 08 41 70 70 2e 6a 61 76 61 15-ый элемент
Tag, соответствует CONSTANT_NameAndType
а значит нам понадобится
CONSTANT_NameAndType_info u1 tag;
u2 name_index;
u2 descriptor_index;
>
и тогда:
ссылка на 7 элемент
00 07 ccылка на 8 элемент
00 08 Учитывая что первый элемент ссылался на это, мы можем заключить что первым был объявлен конструктор класса без параметров. Название класса, мы должны найти в 22 элементе.
16-ый элемент:
Tag, для CONSTANT_Class
c названием в 23 элементе
00 17 17-ый элемент:
Tag, CONSTANT_NameAndType, со ссылкой на 24 и 25 элемент constant_pool
0c 00 18 00 19 18-ый элемент:
Ура «Hello world!»
01 00 0c 48 65 6c 6c 6f 20 77 6f 72 6c 64 21 19-ый элемент:
Tag, для CONSTANT_class c названием в 25-ом элементе
07 00 1a 20-ый элемент:
Tag CONSTANT_NameAndType cо ссылкой на 27 и 28 элемент
0c 00 1b 00 1c 21-ый элемент:
«hello/App»
01 00 09 68 65 6c 6c 6f 2f 41 70 70 22-ой элемент:
«java/lang/Object»
01 00 10 6a 61 76 61 2f 6c 61 6e 67 2f 4f 62 6a 65 63 74 23-ий элемент:
«java/lang/System»
01 00 10 6a 61 76 61 2f 6c 61 6e 67 2f 53 79 73 74 65 6d 24-ый элемент:
«out»
01 00 03 6f 75 74 25-ый элемент:
«Ljava/io/PrintStream;»
01 00 15 4c 6a 61 76 61 2f 69 6f 2f 50 72 69 6e 74 53 74 72 65 61 6d 3b 26-ой элемент:
«java/io/PrintStream»
01 00 13 6a 61 76 61 2f 69 6f 2f 50 72 69 6e 74 53 74 72 65 61 6d 27-ой элемент:
«println»
01 00 07 70 72 69 6e 74 6c 6e 28-ой элемент:
«(Ljava/lang/String;)V»
01 00 15 28 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 29 56 00 21 this_class
00 05 super_class
00 06 00 00 // interfaces_count 00 00 // fields_count methods_count у нас 2 метода в классе, конструктор по умолчанию и метод main:
00 02 Method 1 — Constructor
00 01 - access_flags 00 07 - name_index 00 08 - descriptor_index 00 01 - attributes_count Attribute 1
00 09 // name_index (Code) 00 00 00 1d // attribute_length 00 01 // max_stack 00 01 // max_locals 00 00 00 05 // code_length Один из самых интересных аттрибутов с кодом нашего метода code[code_length], разбор инструкций отдельная большая тема:
2a // aload_0 b7 00 01 // invokespecial (Запустить первый метод в constant_pool) b1 // return Аттрибут закончился и продолжается описание метода
00 00 // exception_table_length 00 01 // attributes_count 00 0a // attribute_name_index (LineNumberTable - 10 элемент) 00 00 00 06 // attribute_length 00 01 // line_number_table_length 00 00 // start_pc 00 03 // line_number Method 2 — main
00 09 // access_flags 00 0b // name_index 00 0c // descriptor_index 00 01 // atributes_count Attribute 1 код метода main
00 09 // name_index (Code) 00 00 00 25 // attribute_length 00 02 // max_stack 00 01 // max_locals 00 00 00 09 // code_length b2 00 02 // getstatic 2, распутывая цепочку будет java.lang.System 12 03 // ldc 3 b6 00 04 // invokevirtual 4 b1 // return 00 00 // exception_table_length 00 01 // attributes_count 00 0a // attribute_name_index (LineNumberTable - 10 элент) 00 00 00 0a // attribute_length 00 02 // line_nuber_table_length 00 00 // start_pc 00 06 // line_number 00 08 // start_pc 00 07 // line_number Описание методов закончено и идет описание атрибутов класса
00 01 // attributes_count 00 0d // name_index (SourceFile) 00 00 00 02 // attributes_length 00 0e // sourcefile_index(App.java) Теперь когда мы закончили с по-байтовым разбором class файла, становится понятно как работает:
javap -c -s -verbose classes/hello/App.class
Он автоматически выводит тоже самое, что я выписал руками:
Classfile /. /classes/hello/App.class Last modified Aug 14, 2015; size 418 bytes MD5 checksum e9d96126a9f5bbd95f154f1a40d46b53 Compiled from "App.java" public class hello.App minor version: 0 major version: 52 flags: ACC_PUBLIC, ACC_SUPER Constant pool: #1 = Methodref #6.#15 // java/lang/Object."":()V #2 = Fieldref #16.#17 // java/lang/System.out:Ljava/io/PrintStream; #3 = String #18 // Hello world! #4 = Methodref #19.#20 // java/io/PrintStream.println:(Ljava/lang/String;)V #5 = Class #21 // hello/App #6 = Class #22 // java/lang/Object #7 = Utf8 #8 = Utf8 ()V #9 = Utf8 Code #10 = Utf8 LineNumberTable #11 = Utf8 main #12 = Utf8 ([Ljava/lang/String;)V #13 = Utf8 SourceFile #14 = Utf8 App.java #15 = NameAndType #7:#8 // "":()V #16 = Class #23 // java/lang/System #17 = NameAndType #24:#25 // out:Ljava/io/PrintStream; #18 = Utf8 Hello world! #19 = Class #26 // java/io/PrintStream #20 = NameAndType #27:#28 // println:(Ljava/lang/String;)V #21 = Utf8 hello/App #22 = Utf8 java/lang/Object #23 = Utf8 java/lang/System #24 = Utf8 out #25 = Utf8 Ljava/io/PrintStream; #26 = Utf8 java/io/PrintStream #27 = Utf8 println #28 = Utf8 (Ljava/lang/String;)V < public hello.App(); descriptor: ()V flags: ACC_PUBLIC Code: stack=1, locals=1, args_size=1 0: aload_0 1: invokespecial #1 // Method java/lang/Object."":()V 4: return LineNumberTable: line 3: 0 public static void main(java.lang.String[]); descriptor: ([Ljava/lang/String;)V flags: ACC_PUBLIC, ACC_STATIC Code: stack=2, locals=1, args_size=1 0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream; 3: ldc #3 // String Hello world! 5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V 8: return LineNumberTable: line 6: 0 line 7: 8 > SourceFile: "App.java" А вот здесь можно посмотреть пример разбора class файла:
ClassFile(InputStream in, Attribute.Factory attributeFactory) throws IOException, ConstantPoolException
Как объяснить, что такое байткод? [закрыт]
Закрыт. На этот вопрос невозможно дать объективный ответ. Ответы на него в данный момент не принимаются.
Хотите улучшить этот вопрос? Переформулируйте вопрос так, чтобы на него можно было дать ответ, основанный на фактах и цитатах.
Закрыт 3 года назад .
Пытался объяснить начинающим инженерам, что такое байткод (в рамках пояснения принципов выполнения Java программ). Так вот, я пытаюсь стандартно объяснить, мол это что то между компиляцией и интерпретацией, типа каждая команда джавовского байт кода, это как несколько ассемблеровских комманд, но они смотрят на меня и говорят — не понятноооо! Они не программисты, не знают что такое ни компиляция, ни интерпретация, ни ассемблер, это я попытался на пальцах им объяснить, и вроде до них что-то дошло, а как можно на пальцах используя жизненные примеры объяснит принцип работы байткода?
Отслеживать
23.4k 3 3 золотых знака 49 49 серебряных знаков 70 70 бронзовых знаков
задан 18 мая 2013 в 20:37
vanyamelikov vanyamelikov
3,113 3 3 золотых знака 30 30 серебряных знаков 59 59 бронзовых знаков
Если они не программисты, то им это не нужно. Не тратьте время.
18 мая 2013 в 20:44
18 мая 2013 в 20:45
Я сам не программист(по образованию), сейчас стоит вопрос проведения расчета охлаждения камеры сгорания ракетного двигателя. Так вот я хочу дать троим студентам эту задачу, на трех разных языках, и посмотреть у кого лучше получиться. Языки: java-среда эклипс, Си++ — Visual Studio и Visual Basic да еще и 6. Сам я его накидал в MathCAD и MathLab. Думаю должен получиться хороший эксперимент!
18 мая 2013 в 20:51
Извините за прямоту — но складывается ощушение, будто отвечающие, сами до конца не понимают, кроме @KoVadim что такое байт код. Не надо мразу минусовать! Вдумайтесь в вопросе было, что необходимо обяснить байт код, при условии понимания небольшого понятий компиляции и интерпретации! А у многих определения можно отнести как к первому, так ко второму и третьему!
19 мая 2013 в 6:05
Хотел было уже написать, но заглянул в Википедию и понял, что ничего добавить не смогу. @vanyamelikov, а Ваши коллеги эту статью читали?
19 мая 2013 в 19:50
7 ответов 7
Сортировка: Сброс на вариант по умолчанию
А нужно объяснять очень просто. Используя их положение. Для начала показываем этим инженерам программу на Java. Например, классический HelloWorld. И спрашиваем — понятно ли? Скорее всего они скажут нет. Объясняем, что и специальной программе, которая исполняет жава код, тоже не понятно. Для этого нужно «разобрать по косточкам».
Теперь делаем «псевдотрасляцию» — как для машинистки (секретарши). Для HelloWorld’а она будет такая.
- настроить окружение (в коде этого нет, но это автоматом) — приготовить бумагу, проверить катриджи.
- взять из памяти строку «привет мир».
- нижимая кнопки, побуквенно ввести сроку (здесь появился цикл:) ).
- почистить все за собой и отнести бумагу заказчику.
Формально — это и есть простой байткод. Только это человеческий байткод. А если в нем стандартизировать все операции и занумеровать, то все может быть сведено к набору чисел. Теперь к реальному байткоду перейти просто.
Легко будет объяснить и переносимость. Если человек (секретарша) выучит все коды операций, то она сможет выполнить любую работу, главное, что бы была последовательность кодов. А инженеры могут попробовать спаять-сконструировать устройство, которое будет это исполнять.
Разница между машинным кодом и байт-кодом
В статье рассматривается ключевая разница между байт-кодом и машинным кодом на примере Java. Байт-код — это промежуточное представление программы, состоящее из инструкций, которые выполняются виртуальной машиной, в то время как машинный код — это непосредственно исполняемый код, специфичный для конкретной аппаратной платформы (компьютера).
Байт-код
Байт-код — это низкоуровневое платформенно-независимое промежуточное представление программы, которое выполняется виртуальной машиной. Одним из примеров языков программирования, использующих байт-код, является Java. Байт-код представляет собой результат компиляции программы, например:
Байт-код выполняется любой подходящей реализацией виртуальной машины (JVM для Java), независимо от того, на какой ОС она установлена. Таким образом, байт-код позволяет однажды скомпилированной программе выполняться на разных платформах, поддерживающих соответствующую виртуальную машину.
Исходный код Java-программы содержится в .java-файлах. Они состоят из объявления и реализации классов, методов, переменных и других конструкций. Файлы .java являются текстовыми файлами, понятными разработчику, и используются в процессе разработки и отладки программы. Файлы .class представляют собой бинарные файлы, содержащие скомпилированный байт-код Java. Они генерируются компилятором Java и являются платформенно-независимым представлением Java-программы. Файлы .class содержат инструкции, понятные для JVM.
При компиляции Java-программы для каждого Java-класса создается соответствующий .class файл, в котором находится скомпилированное в байт-код представление Java-класса. Если в одном .java файле находится несколько классов, то будет создано несколько соответствующих .class файлов. При этом в каждом .class файле содержится представление только одного Java-класса. Подробно о классах мы поговорим позже, а пока можно считать, что Java-класс — это основная структурная единица Java-программы.
Машинный код
Машинный код — это набор инструкций, которые понятны процессору конкретной архитектуры. Он является бинарным (состоит из 0 и 1 ). Различные типы процессоров имеют свои собственные наборы инструкций и форматы машинного кода. Процессор способен понимать и выполнять только машинные инструкции, поэтому программы, написанные на высокоуровневых языках программирования, должны быть скомпилированы в машинный код, чтобы быть исполнимыми на конкретной платформе. В случае с компилируемыми языками программирования, такими как С/C++ или Go, все так и происходит: исходный код приложения компилируется сразу в машинный код целевой платформы (компьютера). Однако интерпретируемые языки программирования, такие как Python или R, позволяют генерировать машинные инструкции во время выполнения программы интерпретатором. Java является гибридом, который совмещает компилируемый и интерпретируемый подходы. Сперва Java-приложение компилируется в промежуточное представление — байт-код, который затем может быть выполнен любым подходящим JRE, используя реализацию JVM:
Примечание: Зачастую JVM посредством JIT-компилятора оптимизирует машинный код, чтобы уменьшить количество инструкций, необходимых для выполнения программы, и отправляет машинные инструкции оптимизированными пакетами — «пачками». Принцип работы JIT-компилятора заключается в том, что при запуске Java-приложения, код программы сначала интерпретируется виртуальной машиной Java (JVM) построчно, а затем, если какой-то участок кода многократно повторяется, этот участок компилируется в машинный код (который напрямую выполняется центральным процессором) посредством JIT-компилятора. Также JIT автоматически оптимизирует код, убирая неиспользуемые инструкции и применяя другие оптимизации, что также способствует ускорению работы приложения.
Разница между машинным кодом и байт-кодом
| Байт-код | Машинный код |
| Промежуточное представление программы. | Набор низкоуровневых инструкций, понятных процессору определенной архитектуры. |
| Платформенно-независимый (может выполняться на любой платформе, на которой установлена подходящая виртуальная машина). | Платформенно-зависимый. |
| Выполняется виртуальной машиной. | Выполняется CPU. |
| Генерируется компилятором из исходного кода программы на языке программирования интерпретируемого типа (однако не каждый интерпретируемый язык программирования использует байт-код). | Является результатом компиляции исходного кода программы на языке программирования компилируемого типа. |
Машинный код и байт код: на каком языке говорит ваша программа?
У тех, кто только начинает знакомиться с Java, довольно часто возникает путаница в понятиях машинный и байт код. Что они собой представляют? В чём различия? В короткой заметке мы постараемся максимально просто и понятно расписать их особенности, чтоб раз и навсегда закрыть этот вопрос.
Машинный код
Процессор — это, по сути, очень сложный и продвинутый калькулятор. У него есть множество ячеек памяти (называемых регистрами) с которыми и между которыми проводятся различные математические и байтовые операции. Машинный код как раз и представляет собой описание последовательности выполнения операций и набора участвующих данных. По сути, это единственный язык, который понимает процессор вашего компьютера.
Врожденная несовместимость
При этом далеко не все процессоры «говорят» на одном языке. Различия есть не только между архитектурами CISC и RISC, но и внутри этих «лагерей».
CISC (англ. Complex Instruction Set Computing) — концепция проектирования процессоров, которая характеризуется следующим набором свойств:
- много команд, разных по длине;
- много режимов адресации;
- сложная кодировка инструкции.
В новых поколениях процессоров внедряют дополнительные наборы инструкций, которые моделям старшего поколения попросту неизвестны. Из-за этого программы, скомпилированные для одной архитектуры (или одного поколения процессоров) не могут работать на другом аппаратном обеспечении. Все это вынуждает заниматься перекомпиляцией программ для обеспечения их работы на других компьютерах. Впрочем, заново компилировать приходится не только из-за процессоров, но и еще из-за различий во взаимодействии программ и операционной системы. Именно из-за них невозможно запустить «виндовую» программу под Linux, а «линуксовую» под Windows.
Байт-код
Байт-код во многом похож на машинный код, только он использует набор инструкций не реального процессора, а виртуального. При этом он может включать в себя участки, ориентированные на использование JIT-компилятора, оптимизирующего выполнение команд под реальный процессор, на котором запущена программа.
| JIT-компиляция (англ. Just-in-time compilation, компиляция «на лету») или динамическая компиляция (англ. dynamic translation) — это технология увеличения производительности программных систем, использующих байт-код, путём компиляции байт-кода в машинный код или в другой формат непосредственно во время работы программы. «Официально» в Java до 9-й версии был только JIT-компилятор. В Java 9 появился ещё один компилятор, причём компилирует он с опережением (AoT). Эта возможность позволяет компилировать классы Java в нативный код перед запуском на виртуальной машине. Данная функция предназначена для улучшения времени запуска и малых, и больших приложений, с ограниченным влиянием на максимальную производительность. |
Для CISC процессоров некоторые инструкции могут объединяться в более сложные конструкции, поддерживаемые процессором, а для RISC – наоборот разбиваться на более простые последовательности команд.
Еще и виртуальная ОС
Впрочем, байт код содержит не только процессорные инструкции. В нем также содержится логика взаимодействия с виртуальной операционной системой, которая делает поведение приложения независящим от используемой на компьютере операционной системы. Это отлично видно в JVM, где работа с системными вызовами и GUI зачастую не зависят от ОС, на которой запущена программа. По большому счету JVM эмулирует запуск процесса программы, в отличие от решений вроде Virtual Box, которые создают только виртуальную систему/железо.
JVM одна такая?
Определенно нет. Тот же DotNet CLI это тоже виртуальная машина, которую чаще всего используют на компьютерах, работающих под Windows с x86 совместимыми процессорами. Впрочем существует ее реализация и под другие системы: приложения под него должны работать в Windows RT запущенной на ARM (RISC) совместимых процессорах, или можно запустить их на Linux/OSX в среде Mono, являющей сторонней (и потому не полностью совместимой) реализацией DotNet для этих платформ. Так что эта платформа, как и JVM, работает на разных процессорах и разных ОС. Существует еще множество похожих решений (как старых, так и новых): LLVM, Flash SWF, и другие. У некоторых языков программирования есть собственные виртуальные машины. К примеру, CPython компилирует исходники из PY в файлы PYC – скомпилированный (compiled) байт код который подготовлен к запуску в PVM. Или есть намного более древний пример — Lisp можно компилировать в файлы FASL (Fast Load). Фактически они содержат AST дерево, построенное генератором из исходного кода. Эти файлы могут быть прочитаны и запущены интерпретатором Lisp на разных платформах, или использованы для создания машинного кода для используемой на данный момент аппаратной архитектуры.