LINUX.ORG.RU

Надассемблер

 , ,


3

2

Интересует язык, который тривиально транслируется в ассемблер. По сути если я пишу на ассемблере, то многие паттерны повторяются чисто механически. Можно макросов под них понаписать, но язык это всё же лучше макросов. Но при этом он должен совершенно очевидным образом преобразовываться в ассемблер, в нём должен быть прямой доступ ко всем регистрам, в любой момент должна быть возможность использовать ассемблер напрямую. Но в то же время он должен быть настолько высокоуровневым, насколько это теоретически возможно для языка такого уровня. К примеру объявить переменную определённого типа, которая будет в стеке и к которой будут применяться правильные JMP-команды и арифметика (signed/unsigned).

Я точно не уверен, но вроде бы на заре времён язык C был чем-то подобным. Но речь о современности. В частности интересует конкретно архитектура ARM Cortex M0.

Что хотелось бы видеть по пунктам:

  1. Объявления функций с переменными. Автоматические прологи и эпилоги.

  2. Типизация переменных (signed/unsigned), понятный синтаксис для сравнений, структурированный код (if/while/…) вместо JMP.

  3. Вызов других функций по стандартным конвенциям.

  4. Статический анализ там, где это возможно.

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

★★★★★

Я точно не уверен, но вроде бы на заре времён язык C был чем-то подобным.

Для PDP-11 оно так и есть.

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

Но речь о современности.

Нет. Речь о конкретной архитектуре конкретного камня и конкретно его ассемблере.

Что хотелось бы видеть по пунктам:

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

Oberstserj ★★ ()

Lisp – на нём маленький DSL пишется за день-другой.

FASM – его система макросов позволяет очень многое.

timdorohin ★★★ ()

Слушай дружище. Современный компилятор генерит код супер изящный. Том Сван нервно курит в сторонке. (Том Сван - профессиональный программист, писатель и просто - хороший Человек (хакер), подпольная кличка Hayden).

anonymous ()

Это примерно Си без оптимизаций. Только я сомневаюсь в полезности этой затеи. На бумаге черновиком я тоже на таком «асме с циклами и функциями» писал, но попытки перевести это в формализованный синтаксис упирались бы в множество мелочей.

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

firkax ★★★ ()

Я точно не уверен, но вроде бы на заре времён язык C был чем-то подобным.

Ну да. register и всё такое. Тебе, скорее всего, нужен свой собственный компилятор Си.

hobbit ★★★★★ ()

Я бы посоветовал тебе язык Fort, он по сей день, есть во многих дистрибутивах.

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

Он и не низкого, и не высокого уровня. Его можно расширять своими операторами. В нём есть встроенный ассемблер.

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

Я,например, столкнулся, на Ryzen Pro, с дополнительными инструкциями Pro версии.

В общем, подумай. Попробуй.

PS: Да, я теперь не анонимус.

Mamluk ()
Ответ на: комментарий от timdorohin

Lisp – на нём маленький DSL пишется за день-другой

А вот кстати да. @Legioner, есть такая балалайка. Но можно и просто CL накатать транслятор.

no-such-file ★★★★★ ()
Ответ на: комментарий от no-such-file

Ну да. Но я об этом предупредил ТС. А уж ему решать. Просто посмотреть и потыркать.

Почитать книгу В.П.Дьяконова, «Язык программирования Fort», старая, но основы есть.

Mamluk ()

Посмотри fasmg и его calf или как-то так.

d ★★★★ ()
Ответ на: комментарий от Mamluk

Fort

Forth.

Да, оно даже в оригинале выглядит затейливым каламбуром. Некоторые книжки русских авторов (не уверен конкретно насчёт Дьяконова) пишут по-русски: ФОРТ.

hobbit ★★★★★ ()
Последнее исправление: hobbit (всего исправлений: 1)
Ответ на: комментарий от firkax

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

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

Legioner ★★★★★ ()
Ответ на: комментарий от hobbit

Тут несколько в ином дело, и это объяснено. Ибо название Fort, по сути Forth, что значит четвёртый, но тогда ЭВМ не позволяли имён, диной более 4-х символов. Язык то древний так то.

А выглядит да, для непосвящённых, как китайская грамота. Но стоит в него втянуться, и становится понятна вся его гибкость и преимущества.

Конечно в OS/2 он выглядел красивее и нагляднее, особенно Зиммеровский вариант, но и в UNIX/Linux тоже не плох.

Mamluk ()
Ответ на: комментарий от Legioner

В GCC (и других) есть __attribute__((naked)), asm(), extern, возможна сборка из асмовских исходников. В GNU Assembler макросы неплохие, могут иметь параметры, в том числе и опциональные.

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

Не нравится как оптимизирует компилятор? — есть два варианта: отключить оптимизацию или переписать кусок на асме. Я, при переписывании на асм, часто опираюсь на листинг компилятора.

Си и асм прекрасно дополняют друг друга, какие тебе ещё нужны инструменты?

anonymous ()
Ответ на: комментарий от Mamluk

тогда ЭВМ не позволяли имён, диной более 4-х символов

Таки всё же пяти. Википедия:

Мур назвал свой язык Fourth, считая, что это будет язык для ЭВМ четвёртого (англ. fourth) поколения. Но так как он работал на машине IBM 1130 (англ.), которая допускала имена, составленные не более чем из пяти прописных букв, название было преобразовано в FORTH (англ. forth — вперёд).

Поэтому да, мне кажется, из русских авторов (а книжек на русском было не меньше трёх, кроме упомянутого Дьяконова, был ещё Семёнов и ещё кто-то), разумнее всего поступили те, кто сразу «русифицировал» название языка и стал писать просто Форт, меньше путаницы.

Конечно в OS/2 он выглядел красивее и нагляднее, особенно Зиммеровский вариант, но и в UNIX/Linux тоже не плох.

Верю. К сожалению, моё увлечение Фортом осталось во времена КР580ВМ80А и магнитной ленты. Помню, писал свой декомпилятор из шитого кода в исходник (этим, думаю, многие начинающие фортеры баловались), и какие-то из уже загруженных разработчиками форт-системы слов он успешно восстанавливал (но не все).

hobbit ★★★★★ ()

понятный синтаксис для сравнений, структурированный код (if/while/…) вместо JMP

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

Писать на асме — это искусство. И его невозможно заменять высокоуровневыми абстракциями. Иначе — тебе не нужен асм.

anonymous ()
Ответ на: комментарий от timdorohin

Lisp – на нём маленький DSL пишется за день-другой.

Чтобы решить задачу, которая решается за час-другой без DSL.

anonymous ()
Ответ на: комментарий от ABW

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

Haskell -> Core -> STG -> C– -> Asm/LLVM

Примерно так. Плюс, небольшие части рантайма на нём. Но совсем небольшие.

В теории, никто не мешает выдрать компилятор Cmm и кодогенераторы для нужных архитектур из GHC и использовать их отдельно. Наверняка уже где-то кто-то пытался. Подробнее про язык можно тут почитать: https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler/cmm-type

hateyoufeel ★★★★★ ()
Последнее исправление: hateyoufeel (всего исправлений: 3)

С– не подойдёт?

den73 ★★★★★ ()
Ответ на: комментарий от hobbit

Возможно и так. Но помимо Дьяконова, более известными были авторы Баранов и Ноздрунов. А Семёнов так, не сильно интересная книга.

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

Во времена i8080, наш аналог был К580ИК(ВМ)80А, он был ещё не очень развитым языком. Позднее, начиная с i80386 уже, он стал довольно мощным языком программирования и вошёл во все справочники, как не имеющий уровня, ни низкого, ни высокого.

Хотя и для ТС тут подсказали более интересную идею с реализацией Lisp конечно. Но выбирать ему. Уж что более понравится.

Успешная реализация Forth языка, от Zimmer, и аж нескольких версий, на том же диске «Библиотека программиста №4», что и упомянутый в теме тут C– язык программирования.

В БК-0011, на совсем другой архитектуры процессоре, шёл в нишу с двумя панельками под ПЗУ, язык PC-Forth стандарта вполне себе. Но я интересовался им как интерпретатором просто, а на предмет целевой компиляции не проверял на БК, в отличие от i8080-i80386.

Mamluk ()
Ответ на: комментарий от ABW

Ох лол! Короче, это два разных Ц Минус Минус. Штука в GHC переносима между архитектурами. Штука из сфинкса — не очень.

hateyoufeel ★★★★★ ()

Автокод Эльбрус? Из лиспов можно посмотреть, как работают бекенды SBCL и CCL

den73 ★★★★★ ()

Интересует язык, который тривиально транслируется в ассемблер.

посмотри HLA aka High-Level Assembler от Randall Hyde, автора книги «The Art Of Assembly» : сайт HLA HLA standard library wiki

также см. его книжку «Art of 64-Bit Assembly» и про HLA v3

его «высокоуровневый ассемблер» подходит по большинству пунктов:

  • синтаксис наподобие паскаля/ады

  • семантика С++ (есть объектно-ориентированная GUI библиотека под Windows, HOWL и аналог STL в HLA standard library, есть шаблоны и исключения)

  • шаблоны сделаны через CTFE макросы; язык макросов весьма расширяемый, наподобие D

  • можно делать native/naked C функции, со своим соглашением о вызове, например через регистры без стека. разумеется, также есть stdcall и pascal. линкуется с С функциями, например libc прозрачно.

  • компилятор HLA реализован через mmap файлы, работает очень быстро: (см. про HLA3: тесты в исходниках, там есть замеры)

  • HLA3 можно допилить чтобы реализовать парсер своего языка (вроде паскаля), лексер/парсер понятно описаны;

  • также в HLA3 есть зачатки в сторону переносимости, перенацеливаемости (например, можно допилить в сторону 64-битности). хотя в целом, не так гибко как в fasmg где вообще несколько настраиваемых парсеров и синтаксисов, и из коробки есть x86, ARM, z80,6502, java class bytecode, .NET CLR ilasm и что-то ещё

  • высокоуровневый HLA транслирует в «обычный» ассемблер вроде MASM, FASM, gas. генерируя обычный понятный map файл. можно посмотреть почему линкуется тот или иной кусок рантайма, например. по gas кстати книжка хорошая " Assembly Assembly From the Ground Up" есть по первой ссылке. ещё можно например исходники ulix os почитать, или сразу ulix-book.nw и ulix-book.pdf – там какой-то скрипт есть на питоне для перевода в AT&T синтаксис/и\или, .intel syntax вставлять автоматически в asm для gcc/gas.

в общем, почти по всем критериям HLA подходит.

при этом это всё-таки ассемблер: несмотря на UFCS-подобный «объектный» синтаксис (на самом деле, модуль/неймспейс.команда) – выражения пишутся на обычном ассемблере, то есть, их нужно писать вручную командами типа mov(eax,ebx); в синтаксисе наподобие вызова функций.

то есть, он почти не добавляет всякой выскоуровневой отсебятины.

насчёт оптимизаций – там этого нет, только то, что напишешь вручную. хотя может можно своего CTFE макросами накрутить, см. примеры и реализацию ООП, STL.

ARM из коробки тоже нет, может допилят в HLAv3.

ещё он про 64-битный ассемблер книжку пишет, может там появится когда-нибудь (изначальный HLA 32-bit only).

в общем, качай и смотри сам: книжку, примеры, программы, библиотеки и «фреймворки» на CTFE макросах.

anonymous ()

dlang, но:

  1. Там интеграция с ASM x86 и официальный компилятор других платформ не поддерживает
  2. Язык мертв
SR_team ★★★★★ ()
Ответ на: комментарий от Mamluk

Почитать книгу В.П.Дьяконова, «Язык программирования Forth», старая, но основы есть.

о да, помню эту книжку. до сих пор помню реализацию метода Рунге-Кутта строчек в 6 ASCII-line noise на форте :)))

вообще, если форт совсем с начала, то имхо лучше зайдёт в таком порядке:

  • Лео Броуди, «Способ мышления – Форт» (Thinking Forth здесь )– как ни странно, книга про структурное программирование, может даже про ООП. хотя ближе к language-oriented frameworks Мартина Фаулера, «Лексикону программирования» академика Ершова, и прочему предметно-ориентированному DSL.

  • Jack Crenshaw, «Let’s write a compiler» – лучше читать новую редакцию, на форте. в первой он реализовал компилятор паскаля на паскале. через emit реализацию ассемблерного выхлопа, ну то есть, с тем же успехом он вполне себе мог его на каком-нибудь HLA написать. или например, на форте. во второй он на форте и переписал – и компилятор недопаскаля стал на мой взгяд, ещё проще и нагляднее – на форте, чем на паскале.

  • статьи на Taygeta.com про форт. например, «Adventures in the Forth Dimension» Julian V. Noble, также очень рекомендую его «A Call to Assembly» J.V.Noble с примерами ассемблера на форте.

ещё был компилятор выражений где-то у него вроде бы в «A FORmula TRANslator for Forth», J.V. Noble, с примерами транслятора фортрана в форт (там по сути вычисление выражений). «FROM PASCAL TO FORTH Leonard Morgenstern»

ещё один компилятор выражений был где-то в исходниках, с макросами форта (CREATE … DOES компилирующими словами). ссылку не помню, наткнулся где-то в районе Taygeta.

как бы не это вот оно: scilib The Forth Scientific Library, FSL

ещё про форт можно читать про метакомпиляторы «на самом себе». например, lbForth

у Rigidus есть несколько хороших статей про реализацию лиспа, и про форт тоже. например, описана самораскрутка jonesforth и определённо стоит почитать про PAF, «Forth как переносимый ассемблер»

в современных реализациях форта (например, Win32Forth или Gforth) порою встретишь всякое:

  • реализацию простой работоспособной ООП

  • FFI с си библиотеками

  • NeHe OpenGL tutorials, переписанные под Gforth

  • ну и конечно, ассемблер там тоже есть.

anonymous ()

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

Пчёл, это всё в обычных ассемблерах есть уже как 30+лет:

     LOCAL dwY: DWORD, dwCounter: DWORD, dwPos: DWORD

    .repeat 
        invoke crt_strcmp, ADDR NONE, proc_name  
        .if eax == 0    
            invoke CharToOemW, ADDR pe32.szExeFile, offset Buffer
            print offset Buffer, 13, 10
        .else
            invoke OemToCharW, proc_name, offset Buffer
            invoke crt_wcscmp, ADDR pe32.szExeFile, offset Buffer
            .if eax == 0
                mov hProcess, 0
                invoke OpenProcess, PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID
                mov hProcess, eax
                invoke TerminateProcess, hProcess, 0
                .if eax == 0
                    invoke CharToOemA, offset ErrClose, offset Buffer
                  
                .else                    
                    invoke CharToOemA, offset OkClose, offset Buffer
                    invoke crt_printf, offset Buffer, proc_name
                .endif
                .if hProcess != 0 
                    invoke CloseHandle, hProcess 
                .endif 
            .endif
        .endif
        invoke Process32NextW, hProcessSnap, ADDR pe32
    .until eax == 0

и к которой будут применяться правильные JMP-команды и арифметика

JMP команды не стоит применять к адресам данных, если ты не знаешь, что ты делаешь.

LamerOk ★★★★★ ()
Ответ на: комментарий от Legioner

в аде GNAT есть asm инструкция, например. примерно так же как в gcc. ещё есть стандартный пакет для ассемблера. и описаны основные системно-зависимые intrinsincs.

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

в общем, не так уж и много по сравнению с тем же HLA получается.

и потом: это же обычный gcc бекенд, с его оптимизациями. можно сделать gcc -x ada -fdumpspec file.cpp -o file.ads для автогенерации врапперов (есть стандартный FFI через pragma(C,import). с C++ чуть сложнее из-за хрупкого ABI, но тоже можно, см. примеры. -fdumpspec вроде и С++ сносно поддерживает).

anonymous ()
Ответ на: комментарий от Mamluk

Конечно в OS/2 он выглядел красивее и нагляднее, особенно Зиммеровский вариант, но и в UNIX/Linux тоже не плох.

после того, как я нашёл на EDM/2 в вики реализацию WPS объектов и SOM объектов на голом ассемблере, я уже ничему не удивляюсь.

в такой вот ассемблер было бы резонно транслироваться с того же форта-с-ассемблером ну или того же самого HLA.

и писать на объектно-ориентированном ассемблере обычные WPS и SOM объекты, напрямую сразу в DLL.

на сайте автора, который писал там в вики про WPS и SOM на ассемблере. есть какой-то прикольный проект про лисп на ассемблере для полуоси. сделать лисп-машину из полуоси, через такой вот объектно-ориентированный асм. ещё у него там про квантовые компьютеры было что-то.

прикольный такой автор, загугли.

anonymous ()
Ответ на: комментарий от hobbit

допускала имена, составленные не более чем из пяти прописных букв

Мой брат одно время пользовался словом «марам». Они на лабе попытались назвать файл «маразм», а система сократила, создав тем самым локальный мемас.
Вспомнилось чот.

thesis ★★★★★ ()
Ответ на: комментарий от anonymous

Писать на асме — это искусство. И его невозможно заменять высокоуровневыми абстракциями. Иначе — тебе не нужен асм.

ну не совсем соглашусь. выскоуровеневый асм имеет свои резоны.

например, ещё в том же MASM макроязык был довольно гибкий, можно было те же .if/.then/.else/.endif или .while/.wend реализовать невозбранно, не только .invoke. был где-то на masm.org пример MASMbasic – бейсика на MASM, в основном, на макросах.

у fasmg макроязык выскоуровневый, парсер и лексер тоже настраиваемый. реализация какого-нибудь Z80, 6502, Java class bytecode наглядна и тривиальна.

у того же самого HLA макроязык ещё более гибкий, в сторону CTFE макросов, как в D. там кажется есть какая-то рефлексия, так что объектно-ориентированная библиотека GUI HOWL под винду и аналог STL, исключения на CTFE макросах в основном и реализованы.

при этом это всё-таки всё ещё ассемблер. потому что компилятора выражений нет, и их нужно писать вручную.

врочем, на примере того же FSL scilibrary, «FORTRAN для форта», компиляторов недопаскалей – подобный компилятор выражений и на форте не так уж сложно пишется.

при этом у форта есть макросы (компилирующие слова), встроенный ассемблер, интроспекция в отладчике, – вот это вот всё.

anonymous ()
Ответ на: комментарий от kawaii_neko

C–

этот? c–sphinx

там вроде два форка было, второй вроде как под винду допиливали.

ну и под Колибри – тоже работает

Сейчас С– умеет генерировать 32-битный код под ДОС и Windows (прим. ред. а также под MenuetOS, KolibriOS).

c–sphinx-master/c–sphinx.narod.ru.zip/FILES/whello_o.zip/HelloW32.c

#pragma option w32
#pragma option obj

?include "windows.h--"


void main()
{
MessageBoxA(0, "Hello world!", "C-- hello", MB_OK);

}

…/_make.bat

del HELLOW32.EXE
del HELLOW32.ERR
del HelloW32.obj
del HELLOW_32.EXE
del W32.ERR
rem -W32
c-- HelloW32.c
D:\fasm\utils\alink\bin\alink HELLOW32.OBJ win32.lib  -subsys gui -oPE -o HELLOW_32.EXE  >>HELLOW32.ERR
rem -entry _demo

alink тоже был крутой линкер, кстати.

anonymous ()
Ответ на: комментарий от thesis

переботинок ваш компьютор!

набери слово «reboot» русскими буквами теми же клавишами в русской раскладке.

там 6 буков, правда.

anonymous ()
Ответ на: комментарий от anonymous

набери слово «reboot» русскими буквами

В 1998 отсмеялся по этому поводу.

thesis ★★★★★ ()
Ответ на: комментарий от Shushundr

rust

слишком толсто : нафига там эти 288k? а если стрипнуть, сколько останется?

вообще, как там собрать свой собственный рантайм без всякой лишней высокоуровневой отсебятины?

например, в аде я могу собрать хелловорд с рантаймом drake

и получить вместо 140k => 75k => 40..50k в gcc-4.8.1, в актуальном 11.2.0 чуточку больше в дефолтном, но те же примерно 40к в новом рантайме.

одним ключиком --RTS=./DRAKE_RTS/Og.

в примерах ещё есть плагин для far на Аda. там стрипают через gnatelim и pragma Eliminate (Win32.Winbase, GlobalAlloc); , например.

ну то есть:

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

  2. стрипать ненужные символы через pragma Eliminate или наоброт, линковаться с нужными через pragma import(С,adaName, "Cname")/pragma Import(Cxx\Stdcall\C,myName,"FFIname") – вполне обычное дело. в том числе, сгенерировать такие прагмы автомаГически.

  3. то, что язык при этом может (значит, должен) оставаться достаточно высокоуровневым, а не превращаться в нечитаемую лапшу linenoise символов – тоже довольно обычное дело.

anonymous ()
Ответ на: комментарий от anonymous

doszip commander dz.asm из состава asmc тоже написан на довольно таки высокоуровневых макросах.

например, вот тут wsub.inc я вижу зайчатки довольно-таки высокоуровнего FFI к Win32 runtime.

чисто теоретически, аналогично fasmlib могли бы и нечто кроссплатформенное Win/Lin в таком же духе написать.

asmc, uasm, jwasm – ЕМНИП, потомки WASM из ваткомовского компилятора. uasm например, написан полностью на С++. остальные большей частью на ассемблере, временами довольно высокоуровневом.

anonymous ()
Ответ на: комментарий от hateyoufeel

три разных Ц–. один исходный Peter Cellik (заброшен), тот только под ДОС. второй Михаил Шекер, допилил до Win32. потом непонятно кто допилил до КолибриОС и МенуэтОС рантаймов.

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

anonymous ()
Ответ на: комментарий от LamerOk

В GNU ассемблере разве есть такое? Masm мне не очень подходит. Но смысл да, примерно такой, разве что смотрится стремновато с этими точками.

JMP команды не стоит применять к адресам данных, если ты не знаешь, что ты делаешь.

Не понял, о чём ты. Я говорю, например, о коде вида if (r0 < r1) { ... }. В данном случае важно понимать, являются ли числа в r0 и r1 знаковыми или беззнаковыми, т.к. в зависимости от этого меняется команда перехода (BLO / BLT). Т.е. удобно было бы в этом языке привязать типы к нужным регистрам/ячейкам памяти, чтобы компилятор выбирал нужную инструкцию (или выдавал ошибку, если идёт попытка сравнения разных типов).

Legioner ★★★★★ ()
Ответ на: комментарий от Legioner

ещё есть вот такой «надассемблер» на Scheme:

Sassy

ну то есть: воткнуть ассемблер в минималистичные лисп/схему или форт – тоже вполне обычное дело.

anonymous ()
Ответ на: комментарий от Legioner

в Programming From The Grounds Up.pdf пишут под линукс на gas/gcc, временами даже в голимом AT&T синтаксисе.

там есть aliasing по переменным, макросы какие-то чуть более высокоуровневые чем простой #define.

например, стр.250 Appenix A: GTK на gas.

но это ещё не показательный пример, слишком мало макросни.

я так понимаю, что в gas тоже довольно продвинутый макроязык. только из-за нечитаемого AT&T синтаксиса с ним лень разбираться.

anonymous ()
Ответ на: комментарий от anonymous

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

function f(signed r0, signed r1, unsigned r2) {
    r3 = r0 + r1;
    unsigned r3;
    if (r3 < r2) {
        return r3;
    }
    signed r3;
    return r3 * r0;
}

Т.е. каждая конструкция тривиально преобразовывается в соответствующий машинный код, а также используется опциональная типизация (на уровне signed/unsigned) для выбора правильных инструкций там, где это необходимо.

Legioner ★★★★★ ()
Последнее исправление: Legioner (всего исправлений: 1)
Ответ на: комментарий от Legioner

(а я делал компилятор схемы

кстати, под D 2.0 есть Pegged на CTFE-макросах. там есть пример CTFE компилятора оберона. думается, в подобном духе можно и транслятор схемы написать.

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

я так понимаю, в этом и смысл: макросами лиспа можно разворачивать в полноценный ассемблер, ну и допилить их до «высокоуровневого ассемблера», может, и метациклически, «на самом себе» (или если сильно не упарываться по SICP, может, и на чём-то мультистадийном, вроде MetaOcaml/Template Haskell/ Converge PL (с питонячьим синтаксисом): вот, например, реализации конечных автоматов – а вот, какой-то очередной недоассемблер )

Что-то вроде (писал не слишком вдумываясь, сорри за ошибки)

попробуй примеры в духе мультистадийного такого вот написать:

Domain specific language implementation There’s only so much pre-caching of results one can do. Converge allows Domain Specific Languages (DSLs) of arbitrary syntaxes to be embedded into it. Converge allows Domain Specific Languages (DSLs) of arbitrary syntaxes to be embedded into it. Wouldn’t it be fun to see how the fib function would look in an idealised assembly language that abstracts away from the specifics of a real-world processor? Normally this would involve flex, yacc, head scratching, and an implementation so fragile that it only works under a full moon. In Converge, a simple layer atop CTMP means that a 10Kb DSL implementation makes it easy to define our own personal assembly language. With this we can then define an interactive version of fib which asks the user for a number in the Fibonacci sequence and prints it out:

import WSI_Asm

func main():
  test := $<>:
    SWI inputi
    CALL fib
    SWI printi
    SWI exit

    //
    // fib(n) reads in an int on R0 and outputs an int on R0.
    //

    fib:
    // This routine corrupts R1 and R2, so push them onto the stack.
    PUSH R1
    PUSH R2
    IF R0 == 0 JMP fib0 // fib(0) == 0
    IF R0 == 1 JMP fib1 // fib(1) == 1
    // fib(n) where n > 1
    R1 := R0
    R0 := R1 - 1
    CALL fib
    R2 := R0
    R0 := R1 - 2
    CALL fib
    R0 := R2 + R0
    JMP fib_finish
    fib0: // fib(0) == 0
    R0 := 0
    JMP fib_finish
    fib1: // fib(1) == 1
    R0 := 1
    fib_finish:
    POP R2
    POP R1
    RTN

  test.new().exec()
anonymous ()
Ответ на: комментарий от anonymous

на примерах про конечные автоматы, кстати, должно быть элементарно просто реализовать что-то вроде тех двух архитектурных моделей, схем связей и схем состояний в SWITCH-технологии от А. Шалыто.

ну то есть, это всё в какую-то вполне конкретную языковую среду достаточно высокоуровневую вроде (лиспа/форта/питона/MetaOcaml/TH/…/D/Rust/HLA) погрузить, с непосредственно исполняемыми дабы потыкать – интерактивно, модульно и (непосредственно «языково-интегрированными») DSLями, описанными на «самом себе».

невозбранно достигнув желаемого.

anonymous ()
Для того чтобы оставить комментарий войдите или зарегистрируйтесь.