На главную
ПРАВИЛА FAQ Помощь Участники Календарь Избранное RSS
msm.ru
! Перед отправкой сообщения внимательно прочтите правила раздела!!!
1. Запрещается обсуждать написание вирусов, троянов и других вредоносных программ!
2. Помните, что у нас есть FAQ раздела Assembler и Полезные ссылки. Посмотрите, возможно, там уже имеется решение вашего вопроса.

3. Настоятельно рекомендуем обратить особое внимание на правила форума, которые нарушаются чаще всего:
  3.1. Заголовок темы должен кратко отражать её суть. Темы с заголовками типа "Срочно помогите!" или "Ассемблер" будут отправляться в Корзину для мусора.
  3.2. Исходники программ обязательно выделяйте тегами [code]...[/code] (одиночные инструкции можно не выделять).
  3.3. Нежелательно поднимать старые темы (не обновлявшиеся более года) без веской на то причины.

Не забывайте также про главные Правила форума!

Добро пожаловать и приятного вам общения!!! ;)
 
Модераторы: Jin X, Qraizer
  
> Разработка своего ассемблера
    Всем привет!

    Тему создаю просто для отделения вопросов сабжа из темы "fasm синтаксис".

    Предыстория

    Цитата Jin X
    Вот захочу я свой асм создать (вернее, я уже хочу... начну, хотел сказать), а там такое будет! Тогда вообще непонятно станет, как дальше жать.
      JoeUser
      Разработчики ассемблеров давно поняли что главное это мода. Поэтому у каждого свой синтаксис. Это только Зубов умудрился написать один код для 3-х ассемблеров TASM|MASM|NASM.

      Цитата Jin X @
      Вот захочу я свой асм создать (вернее, я уже хочу... начну, хотел сказать), а там такое будет! Тогда вообще непонятно станет, как дальше жать.

      Вывод в IR LLVM он транслирует код под разные платформы.

      А что вас останавливает начать? Я вот к примеру начал и не только ассемблер.

      user posted image

      Это сообщение было перенесено сюда или объединено из темы "fasm синтаксис"
        Цитата Pavia @
        А что вас останавливает начать?
        1. Сначала нужно нормально проработать основные концептуальные особенности этого ассемблера. Делать "ещё один асм" смысла нет. Если уж делать, то так, чтобы он был лучше уже существующих решений по многим параметрам: давал больше возможностей, имел более удобный макродвижок, поддерживал множество выходных форматов файлов и платформ, имел обширную библиотеку функций (хотя бы на уровне masm32) и при этом работал быстро. Он должен вобрать в себя все самые интересные из существующих фишек (например, virtual, match и used из fasm – прекрасные штуки; макросы, которые могут возвращать значения в masm32 – тоже отлично) и иметь свои оригинальные фишки. Должна быть IDE.

        Я записываю идейки в "блокнотик", конечно, но всё это нужно более чётко проработать. По-хорошему, нужно создать форум, где можно было бы вести обсуждение идей, собирать идеи от людей, что-то выносить и на голосование.
        Вот к примеру, несколько из идей:
        а) Система плагинов, которая позволяет расширять ассемблер новыми инструкциями, форматами файлов (в fasmg это сделано через макросы, но всё это работает не очень быстро, и я не уверен, что это удобно разрабатывать), директивами-функциями, псевдоинструкциями (к примеру, реализация деления через умножение; те же .if-ы). Возможно, какие-то оптимизирующие модули (скажем, замена mov eax,0 на xor eax,eax – где это допустимо, т.е. тут нужен анализатор), возможность писать mov eax,[edx*3] с автозаменой его на mov eax,[edx*2+edx] и т.п.
        б) Макродвижок с возможностью использования Си-подобного синтаксиса, регулярных выражений, поддержкой if-ов на все случаи жизни (в т.ч. однострочные типа if (x==y) { mov ax,bx } else { mov cx,dx }), функций для работы со строками, возможности использования констант внутри строк (как в python/ruby), форматирования строк, удобного копирования участков кода из другого места, поддержкой длинных целых (хотя бы до 1024 бит), работой с числами с плавающей запятой (ни masm32, ни fasm, ни nasm не позволяют делать вычисления с вещественными числами в макросах).
        в) Области видимости переменных, процедур, меток, возможность их объявления в любом месте кода с фактическим их переносом в заданную область. Использование строк в коде (например, mov eax,&'Hello World' будет записывать строку в секцию данных, а в eax – адрес).
        г) Включение и выключение разных фишек (которые так же можно проверять через if-ы). Например, AT&T-формата, GAS-подобных указаний размерности (movl, addb), разного порядка байтов в строковых константах.
        д) Генератор чистого исходника (т.е. после препроцессора). Испорт и экспорт в/из других ассемблеров.
        е) Портал для хранения (и автоматической установки/загрузки) библиотек, include'ов, плагинов.
        И пр...

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

        Это сообщение было перенесено сюда или объединено из темы "fasm синтаксис"
          Хм-м-м... "if( x==y )" делаете, а "ax=bx" даже не написали! А ведь в С-- уже таковое было!! :P
            Славян, тут основные идеи, вернее лишь часть. Все эти ax=bx; mov eax,[edx*3]; add ax,cx+cf; add eax,edx*4+0x1000; .push eax,edx { ...code... } и пр. будут в отдельных плагинах, которые можно подключать при желании.
            Как в fasm/nasm сейчас? Если не указана разрядность, подразумевается 16 бит. Если не указана секция, подразумевается .code и т.д.
            И здесь, если не указана платформа, подразумевается полный набор x86-64 (и соответствующий плагин). Если не указан charset, подразумевается utf8. Не указан размер таба, подразумевается 4 (или 8).
            А так можно будет и выравнивание данных (по умолчанию, как в ЯВУ) указывать. И соглашение о вызовах (как в masm), и даже автоматически сохраняемые в процедурах регистры (всегда или если только они используются).
            И можно проверки включать и выключать. К примеру, используешь imul, а тип данных – беззнаковых, получи warning. Если нужно, конечно, по умолчанию выключено.
              Просто трудно представить себе плагин, кой '=' переопределяет/доопределяет. Покажете? Или у вас и для формата плагина будет некий свой язык?..
                Славян, у меня нет пока ничего. Я ж говорю, что это всё нужно ещё проработать. Но этот вопрос решаемый. Навскидку, плагины могут содержать списки регулярных выражений (не обязательно стандартные RegExp, а свои), на соответствие которым будут проверяться выражения в исходнике. Возможно, это не самый лучший вариант, но один из возможных. Более оптимальные идеи могут прийти, если заняться изучением технологии парсинга исходных текстов и создания компиляторов, в которых я пока не шарю.
                Я ж говорю, что одна из основных проблем – найти время на всё это.
                  Я просто хочу сказать, что выбор основ (аксиом) крайне важен. Столько раз сталкивался с тем, что именно этот шаг самый трудный. Вон, Си-шники тоже, наверное, хотели рационально сделать "A = B+C" для матриц, но не смогли и пришлось целый почти новый язык сочинить для этой перегрузки оператора '+'; а вы тут так просто обмолвились про "ax=bx" (плагины!). :blush:
                    Вас послушать, так возникает вопрос "а нафига тогда C нужен?". Зачем вам ассемблер в таком случае?
                      Вот! Согласен с Qraizer'ом!
                      Суть то ассемблера всё же в том, что там каждая команда особенная, и является, по сути, аналогом машинной команды!!!
                      Т.е. команду "ax=bx" можно сделать, а вот "ax=bx=cx" уже нежелательно, ибо у неё нет аналога.
                      Так и с вашим, Jin X, вариантом: "if( x==y )" делать нельзя, ибо нет такой готовой. А вот "if( x==dx )" можно. :)
                      В общем, трудная база ожидается...
                        Цитата Славян @
                        Суть то ассемблера всё же в том, что там каждая команда особенная, и является, по сути, аналогом машинной команды!!!

                        Давняя мудрость - "все хорошо вмеру" :lol:
                        Есть вещи, которые реально удобны, и, самое главное, наглядны. Типа fasm'овский макро "proc/endp", например:

                        ExpandedWrap disabled
                          proc WindowProc stdcall uses ebx esi edi,\
                                 hwnd:DWORD,wmsg:DWORD,wparam:DWORD,lparam:DWORD

                        Избавляет от предшествующих многочисленных push и последующих pop, видны используемые параметры. Ну супер же, не?!!

                        А вот всякие там .if - это, ИМХО, от лукавого. Это точно уже путь в недо-Си.
                          Цитата JoeUser
                          видны используемые параметры. Ну супер же, не?!!
                          Очень часто, конечно, супер. Но! Когда вызываемая функция берётся один-два раза, и первый аргумент с выходным значением вам насильно навязывают EAX, то это крайне редко, но всё же выглядит аки ядовитая кость в горле!!! >:(
                          Типа, за меня решили "что и куда пойдёт". Именно с этого места, как мне думается, (ну или близко к этому) начинается гибель/смерть ассемблера и уход к языкам более высокого уровня. Не могу такового простить! Уж сколько раз вижу, что EBX свободен, его используй, компилятор (Си'шный, имеется ввиду)! Ан нет, своё давит! Меняет, передвигает и ещё чёрт знает что делает, но чтобы в этот долбаный первый EAX засунуть.
                            Цитата Славян @
                            Но! Когда вызываемая функция берётся один-два раза, и первый аргумент с выходным значением вам насильно навязывают EAX, то это крайне редко, но всё же выглядит аки ядовитая кость в горле!!!

                            Упс ... не понял, а при чем тут макро proc? :-?
                              Цитата Славян @
                              Т.е. команду "ax=bx" можно сделать, а вот "ax=bx=cx" уже нежелательно, ибо у неё нет аналога.
                              ax=bx=cx вполне понятно как перевести в ассемблер:
                              ExpandedWrap disabled
                                mov bx,cx
                                mov ax,cx
                              По крайней мере, если описать, что это будет так (типа как в плюсах же есть чёткое описание каждой "запятой").
                              В любом случае, повторюсь, это всё расширения, которые плагинами реализуются. Никто не заставляет их использовать и даже включать плагин в исходник (через "use" или т.п. директиву).

                              Цитата Qraizer @
                              Зачем вам ассемблер в таком случае?
                              Ответ, в общем-то, тот же (хочешь – используй, не хочешь – нет). Не могу сказать, что ax=bx мне прям больше нравится, чем mov ax,bx. Но вероятно, просто из привычки. Если кому-то так будет удобнее, почему бы и нет? С другой стороны, это создаёт неоднозначность синтаксиса, что не есть хорошо (типа как в masm: хочешь пиши mov ax,msg, хочешь mov ax,[msg]). Вероятно, при использовании плагинов расширения синтаксиса нужно делать отдельный суб-язык со своим расширением имени файла, чтобы не смешивать пиво с белым вином. С другой стороны, в некоторых ассемблерах есть расширения типа .if/.else/.endif, .while и т.п. И люди этим даже пользуются! В общем, надо думать. Наверное, некоторые расширения (типа .if, .while, .push и т.п. можно разрешить в основном асме, остальные же – выносить в отдельный а-ля .asmx).

                              Цитата Славян @
                              Так и с вашим, Jin X, вариантом: "if( x==y )" делать нельзя, ибо нет такой готовой.
                              Друг мой, это макрокоманда.

                              Цитата Славян @
                              Именно с этого места, как мне думается, (ну или близко к этому) начинается гибель/смерть ассемблера и уход к языкам более высокого уровня.
                              В том же fasm можно писать так:
                              ExpandedWrap disabled
                                invoke  MessageBox, 0, invoke GetCommandLineW, 'Command line', MB_OK
                              Почему бы и нет? :)
                                Цитата JoeUser
                                при чем тут макро proc?
                                При том, что тоже есть жёсткая привязка к конкретным регистрам, а не к reg1, reg2, reg3.

                                Цитата Jin X
                                ax=bx=cx вполне понятно как перевести в ассемблер:
                                1. В Си то строка "a=b" интерпретируется как "положить 'b' в 'a' и вернуть 'a'", т.е. "на Си" перевод формальный должен быть как:
                                ExpandedWrap disabled
                                  mov bx, cx
                                  mov ax, bx
                                2. Да, ваш то перевод был быстрее для работы (двойное чтение готового), но всё же это уже оптимизация какая-то. Да и, повторюсь, это набор команд, а не одна готовая, из чего ассемблер состоит!

                                Цитата Jin X
                                Цитата Славян
                                "if( x==y )" делать нельзя, ибо нет такой готовой.
                                Друг мой, это макрокоманда.
                                Эх, опять! Тема не про макрокоманды, а про СВОЙ АССЕМБЛЕР! Плевать, что там можно насочинять в макросах, хоть "main={return 'Hello,world!';}", давайте обсудим же чистый свой асм!

                                Цитата Jin X
                                В том же fasm можно писать так:
                                ExpandedWrap disabled
                                  invoke  MessageBox, 0, invoke GetCommandLineW, 'Command line', MB_OK
                                Почему бы и нет?
                                1. Потому что fasm - не ассемблер, а компилятор оного. :wall:
                                2. Потому что видел в Си-вижуалке (при включённых настройках в оптимизации, конечно), что он пихает часть аргументов в стэк, а меж ними ещё какие-то завершающие/(грядущие?) расчёты идут. И это - неспроста! Значит так быстрее будет. В этом же invoke (блин, опять про макросы!) будет чёткая последовательность push'иков, что слегонца, но губит чистый ассемблер.

                                Добавлено
                                Хм... пардон, вики пишет, что fasm как бы и сколько-то ассемблер, и компилятор. Всё же в 99%-смысле это компилятор, думается мне. :blush:
                                  Цитата Славян @
                                  При том, что тоже есть жёсткая привязка к конкретным регистрам, а не к reg1, reg2, reg3.

                                  Откуда ты это взял??? :blink: Я полез смотреть макрос, не увидел такого. Или плохо смотрел ... Покажи где ты это увидел!

                                  Добавлено
                                  Цитата Славян @
                                  Потому что fasm - не ассемблер, а компилятор оного.

                                  Вот это поворот! :) А разве есть Стандарт Ассебмблера?
                                    Учитывая вики, Джо:
                                    Цитата вики.Язык ассемблера
                                    В русском языке (Язык ассемблера) может именоваться просто «ассемблером» (типичны выражения типа «писать программу на ассемблере»), что, строго говоря, неверно, так как ассемблером именуется утилита трансляции программы с языка ассемблера в объектный код компьютера.
                                    Я вполне не так мог понять название/значение темы. Очень прошу уточнить, а то действительно мы о разном можем говорить... :oops:
                                      Цитата Славян @
                                      Очень прошу уточнить, а то действительно мы о разном можем говорить..

                                      Да тут все просто. На 99% речь идет о расширениях функционала существующих компиляторов. В некотором случае это можно решать макросами, коими напичкан, fasm. А вот Jin X уверен, что при должных и возможных временных затратах можно сделать еще более удобный, более удобно расширяемый компилятор. Я специально спрашивал на счет синтаксиса fasm в соседней теме. Стандарта нет, но есть особенности и расширения. Мне это напоминает чем-то Forth, хотя ооче-очень немного. Там так же идет расширение путем определения собственного словаря. Чем не тутошнее расширение макросами?
                                        Тогда всё, закругляюсь. Чисто о само́м языке, думалось! Пардон.
                                          Цитата Славян @
                                          т.е. "на Си" перевод формальный должен быть как
                                          С точки зрения оптимизации мой вариант лучше. Хотя современные процессоры такое сами умеют делать.
                                          Да и C/C++ тоже оптимизируют "как надо": https://gcc.godbolt.org/z/dF9DoP

                                          Цитата Славян @
                                          Эх, опять! Тема не про макрокоманды, а про СВОЙ АССЕМБЛЕР! Плевать, что там можно насочинять в макросах, хоть "main={return 'Hello,world!';}", давайте обсудим же чистый свой асм!
                                          А макродвижок – это не часть ассемблера? К тому же, не я начал комментировать этот if :)

                                          Цитата Славян @
                                          Потому что fasm - не ассемблер, а компилятор оного.
                                          Ну так, и мы тоже обсуждаем тут новый лишь компилятор (и диалект), а не язык как таковой.

                                          Цитата Славян @
                                          что слегонца, но губит чистый ассемблер
                                          Так, зачем новый асм нужен? Берём fasm или nasm и пишем ассемблерные инструкции сплошняком!
                                          А заголовки через db – чище не придумаешь! :jokingly:

                                          Цитата JoeUser @
                                          А вот Jin X уверен, что при должных и возможных временных затратах можно сделать еще более удобный, более удобно расширяемый компилятор.
                                          На самом деле не только в расширениях дело (но и в них тоже), но и в ядре компилятора, который макросами не изменишь.
                                          К примеру, что мне не нравится в fasm:
                                          1. Блоки if не работают с include или equ внутри них. Оказалось, что препроцессор fasm делает несколько проходов: сначала создаёт символьные литералы fix, затем equ и обрабатывает include, а затем уже компилирует и там же проверяет if'ы. Т.е. include сработает в любом случае, вне зависимости от условия в if. Это, конечно, решаемо через match, но это треш, неудобно и создаёт свои сложности, ИМХО.
                                          2. Макросы не могут возвращать значения.
                                          3. Слишком много всего прописано макросами, что вызывает проблемы (скажем, чтобы подключить библиотеку, который нет в стандартных win32ax.inc и т.п., нужно городить огород либо переписывать макросы library и import). Можно, конечно, переписать все макросы и распространять их отдельно, но нужно ли?
                                          4. Нельзя переключать секции туда-сюда. Скажем, написать .code ... .data ... .code ... .data нельзя. Вернее, можно, но у нас тогда будет 4 секции, а не 2.
                                          5. Нельзя через if различить некоторые типы символьных литералов (скажем, число и метку, в т.ч. несуществующую).
                                          6. Отсутствие работы с floating-point в макросах (т.е. даже dq 3.1415927/4 написать нельзя).
                                          и т.д...
                                          И так можно про каждый асм написать.

                                          Цитата Славян @
                                          В русском языке (Язык ассемблера) может именоваться просто «ассемблером», что, строго говоря, неверно, так как ассемблером именуется утилита трансляции программы с языка ассемблера в объектный код компьютера.
                                          Да, это не очень правильно, но здесь под ассемблером понимается именно отдельный диалект.

                                          Цитата Славян @
                                          Чисто о само́м языке, думалось! Пардон.
                                          Что именно подумалось? Что мы сейчас новые инструкции ассемблера изобретать будем? :huh:
                                            Цитата Jin X
                                            Что именно подумалось? Что мы сейчас новые инструкции ассемблера изобретать будем?
                                            Нет, конечно. Подумалось, что вы предложете новое наименование/обозначение машинным командам=инструкциям (что, собственно, я и начал, написав 'ax=bx').
                                              Славян, новые названия смысла придумывать нет, потому что все уже привыкли, а вот новые способы написание кода – возможно. Но повторюсь, что это должен быть отдельный суб-язык, ИМХО, чтобы труЪ-ассемблерщики не обплевались.
                                              Тогда можно и ax=bx, и ax++, и bx-=cx+cf, и eax+=edx*4+0x1000 и всё прочее делать. И даже конструкции, которые преобразуются в несколько инструкций (типа ax=bx+cx и т.п.). Есть же, HighLevel-ассемблеры, правда, мало кто ими пользуется...
                                              По идее, можно обозначить регистры, которые можно использовать для промежуточных вычислений (предварительно директивой, либо, например, так: eax=var*7+[ecx]*(ebx++) #edx,ecx), и тогда много чего можно сделать.
                                                Мне просто вот что подумалось, Jin X: Си-шники стали писать свои программы и увидели, что им часто неплохо было бы и вектора складывать/умножать и матрицы, и т.д. И увидели, что обычная научная запись в языке Си вроде как имеется: v = p + q, A = B*C; Но оказалось, что делать таковое со сложными объектами нельзя, язык не позволяет. Вот и пришлось создать над-язык Си++.
                                                Мораль: если бы был естественный язык ассемблера, кой не шаблонные (команда, арг1, арг2) строки бы писал, а понятные простому обывателю (eax=ebx+ecx <-> lea eax, [ebx+ecx]), то создатели процессорных команд AMD/Intel/... глазами бы увидели, что народу надо! А не городили бы малополезные современные добавки "сложим группу из 4 чисел с другой такой группой".
                                                Посему думается, что САМ начальный язык тоже очень и очень важен. :blush:
                                                  Цитата Славян @
                                                  создатели процессорных команд AMD/Intel/... глазами бы увидели, что народу надо! А не городили бы малополезные современные добавки "сложим группу из 4 чисел с другой такой группой".
                                                  Я думаю, что они прекрасно знают, что нужно людям, а не от балды придумывают, что в голову взбрело. Там помимо "сложим группу из 4 чисел с другой такой группой" есть операции и посерьёзнее, в т.ч. скалярное произведение векторов, поиск минимумов-максимумов, умножение-сложение, обратный квадратный корень, даже работа со строками (через SSE/AVX). А также кодирование AES, расчёт SHA, CRC, работа с полями Галуа, генерация случайных чисел, инструкции для более удобной работы с длинными числами, разные битовые операции. И многое другое. Даже чтение из нескольких разных адресов или запись в несколько разных адресов (одной операцией).
                                                  Там не менее умные люди сидят, чем мы.
                                                    К примеру, вот приведение 16 строчных букв к заглавным (остальные символы остаются без изменений) с использованием SSE2:
                                                    ExpandedWrap disabled
                                                      ; Блок инициализации (выполняется 1 раз):
                                                      mov eax,(127-'z')*01010101h
                                                      movd xmm2,eax       ; mov eax value to lower dword of xmm2
                                                      mov eax,(127-26)*01010101h
                                                      movd xmm3,eax       ; mov eax value to lower dword of xmm3
                                                      mov eax,20202020h
                                                      movd xmm4,eax       ; mov eax value to lower dword of xmm4
                                                      pshufd xmm2,xmm2,0  ; fill entire xmm2 register by lower dword value
                                                      pshufd xmm3,xmm3,0  ; fill entire xmm3 register by lower dword value
                                                      pshufd xmm4,xmm4,0  ; fill entire xmm4 register by lower dword value
                                                       
                                                      ; Преобразование содержимого XMM0, результат будет также в XMM0:
                                                      movdqa xmm1,xmm0    ; temp register
                                                      paddb xmm1,xmm2     ; shift each byte with lower case letter to high signed short int values
                                                      pcmpgtb xmm1,xmm3   ; compare each byte with high 26 signed values and store 0xFF (if in range)
                                                      pand xmm1,xmm4      ; mask with 20h (difference between upper and lower case)
                                                      psubb xmm0,xmm1     ; convert each byte to upper case
                                                      Эх, Jin X, не это народу надо, не это!
                                                      Вот откопал у себя файл 2009 года с командами-хотелками:
                                                      ExpandedWrap disabled
                                                        1.FROOT ; FROOTS ; CROOTS, FINDROOTS, FSQRTS, FINDSQRTS, SSQRTS=Search SQuare RooTS
                                                        ;без аргументов !?
                                                        Вход:ESI(RSI) - адрес коэффициентов (комплексных?)
                                                            EDI(RDI) - адрес места, куда класть корни (или же первый=один=какой-то класть в ST(0), ST(1)-мнимая часть?)
                                                            CL = степень многочлена
                                                        Выход:EDI(RDI) - корни (или же первый=один=какой-то класть в ST(0), ST(1)-мнимая часть?)
                                                            Флаги: ZF=1,если нет корней(как это?), OF=1,если они не влезли
                                                        Проблемы: а) Старший коэф.=0.
                                                        Возмож_решения: а) Считать старший=1 (но нежелательно...)
                                                         
                                                        2.RAND
                                                        ;без аргументов !?
                                                        Вход:ничего
                                                        Выход:случайное целое число в EAX(RAX), равномерно распределённое
                                                        Замечание: надо бы и плавающее (в диапазоне [ST,ST(1)] или [0,1] ? )=FRAND
                                                         
                                                        3.FGAMMA
                                                        Вход: fword/qword ptr - число x (x!= 0; -1; -2; ...)
                                                        Выход: значение гамма-функции
                                                        или же FACTOR
                                                        Вход: fword/qword ptr - число x (x!= -1; -2; ...)
                                                        Выход: значение факториала
                                                         
                                                        4.FRSPHERE - радиус описанной окружности + центр оной
                                                        Вход: 6 чисел в ST(0-5) = {x1,y1,...,x3,y3} - 3 точки треугольника
                                                        Выход: ST(0)-радиус окружности, ST(1-2) - центр её
                                                        Замечание: а) 3 точки на прямой лежат => радиус = +бесконечности(+∞), центр в бесконечности(∞)
                                                        б) всё можно сдвинуть, чтобы одна из точек была нулём, а тогда надо задавать 4 значения (2 точки).
                                                      Ну вот с п. 2 они угадали, сделали RDRAND (целый пока только, правда).
                                                        Славян, какому народу это надо? Это надо не народу, а одному конкретному человеку :)
                                                        1,3,4 - довольно узкие задачи, коих тысячи (FROOTS – решение квадратных уравнений или что?) Часто ли в производстве видео, 3D-графике, DSP, сведении звука, распознавании и синтезе речи, задачах искусственного интеллекта и т.п. используются квадратные уравнения? В чём проблема реализовать это самому?

                                                        Я бы тоже хотел что-то, скажем, SIMD-деление целых чисел, SIMD-синусы и логарифмы, работу со 128 и 256-битными целыми (почему нельзя рассмотреть YMM как одно целое число и умножить его на другое?)
                                                        А ещё я хочу, чтобы был пользовательский флаг, который не менялся бы в результате арифметических операций (скажем, UF), а менялся бы через CLU, DTU, CMU и были соответственно JU, JNZ.
                                                        И т.д.
                                                        И мне тоже кажется странным, что такого не сделали. Тем более, user flag, как мне сказали, есть в некоторых даже 8-битных процессорах. Но это мои личные хотелки. FROOTS мне нафиг не нужен. И если мы опросим ещё 100 человек, у каждого будут свои пожелания.
                                                          Цитата Jin X
                                                          FROOTS – решение квадратных уравнений или что?
                                                          Шире: корни многочлена n-ой степени (я ж написал, что CL-степень многочлена).

                                                          Ещё б какую-то: REVERS (ESI-строка, CX-длина) - реверс строки.

                                                          Цитата Jin X
                                                          И если мы опросим ещё 100 человек, у каждого будут свои пожелания.
                                                          Это стандартная отговорка. Вот только людей очень много, а желаний - не очень. И так бы люди вместе выявили, что им действительно НАДО.

                                                          FGAMMA - узкая, но когда я 12 лет назад попросил разработчиков NDN (Necro... Dos Navigator) добавить её в калькулятор, то добавили!
                                                          Цитата whatsnew.txt
                                                          CALCULATOR
                                                          Gamma-function - is the function, so that G(n+1) = n! But it determine with real x, but not integer !!!
                                                          Так что, теперь, писать и в AMD/Intel, чтобы добавили??? :-?
                                                            Не думаю, что желаний будет мало, если создать отдельную тему об этом.

                                                            Цитата Славян @
                                                            Так что, теперь, писать и в AMD/Intel, чтобы добавили???
                                                            То бензин, а то дети. То DN, а то Intel.
                                                            Можно и написать. Если будет толк, буду только рад :)

                                                            REVERS – тоже узкая операция.
                                                            Может, тогда и INT2STR, STR2INT? :P

                                                            А вот я хочу MOVSBW – читаем байт, пишем слово (старший байт сохраняем постоянным) :o
                                                            И соответственно MOVSWD/MOVSDQ...
                                                              Цитата Jin X @
                                                              Не думаю, что желаний будет мало, если создать отдельную тему об этом.
                                                              Можно попробовать. Только очень хочется, чтобы по существу писали, а не очередной холивар случился, как это часто тут у нас бывает. Хотя ассемблерщиков здесь маловато, кажись...

                                                              Цитата Jin X @
                                                              Можно и написать. Если будет толк, буду только рад
                                                              Увы, но толк может выйти лет чрез 5, думается. Что великовато для столь скромных желаний. Да и я не стану писать, - вот если б кто статусом повыше... Или же в change.org опять??? :wall:

                                                              Цитата Jin X @
                                                              REVERS – тоже узкая операция.
                                                              Согласен. Просто сразу на ум пришло.

                                                              Цитата Jin X @
                                                              Может, тогда и INT2STR, STR2INT?
                                                              Неплохо! В AL-система счисления, CL-длина строки? Или так:
                                                              INT2STR [адрес], reg=число, reg8=сист. счисления
                                                              STR2INT reg=число, [адрес], reg8=сист. счисления ;до 0 в строке или докуда идёт считывание?
                                                                Цитата Славян @
                                                                Хотя ассемблерщиков здесь маловато, кажись...
                                                                Я думаю, что человек 5 вполне хватит для нормального диалога.
                                                                Другое вопрос – что это даст? Мы будет Intel'у отправлять это всё?

                                                                Цитата Славян @
                                                                Увы, но толк может выйти лет чрез 5, думается.
                                                                Была бы группа побольше и посерьёзней... с обоснованием – зачем.

                                                                Цитата Славян @
                                                                до 0 в строке или докуда идёт считывание?
                                                                Не знаю, это скорее шутка была :)
                                                                  Ещё пару фишек придумал:

                                                                  1. Перевод кода внутри #{} в числовое значение:
                                                                  ExpandedWrap disabled
                                                                    mov eax, not #{xor ecx,ecx}

                                                                  2. Оптимизация отдельных инструкций.
                                                                  По размеру:
                                                                  ExpandedWrap disabled
                                                                    *mov eax,0  ; преобразуется в xor eax,eax
                                                                  По скорости:
                                                                  ExpandedWrap disabled
                                                                    +dec eax  ; преобразуется в sub eax,1
                                                                    Неоднозначность же в п.1 - есть код, у коего разные варианты машинного представления.
                                                                      Славян, и что?
                                                                      Когда мы пишем xor ecx,ecx в коде, тоже есть разные варианты, но компилится в один, никого не спрашивая. А если это важно, то это решается другими способами: специальными всякими, например
                                                                      ExpandedWrap disabled
                                                                        xor ecx,ecx !rmsrc
                                                                        xor ecx,ecx !rmdst
                                                                      (обозначать, как вариант, можно и по-другому).

                                                                      Т.е.
                                                                      ExpandedWrap disabled
                                                                        mov eax, ~ #{
                                                                            xor ecx,ecx !rmsrc
                                                                            xor edx,edx !rmdst
                                                                          }
                                                                         
                                                                        push hidword double(3.14159265358979)
                                                                        Да ничего, ничего! :blush:
                                                                        Просто некоторая неприязнь к некоей неоднозначности... Спустя годы народ забудет отчего так, и будут вопросы с выражением: :blink:
                                                                        0 пользователей читают эту тему (0 гостей и 0 скрытых пользователей)
                                                                        0 пользователей:


                                                                        Рейтинг@Mail.ru
                                                                        [ Script execution time: 0,0843 ]   [ 18 queries used ]   [ Generated: 25.06.21, 10:13 GMT ]