<bgdev />free

Вход Регистрация

Assembly
0

#108179 (ツ) palavrov
Създадено на 04.06.2024, видяно: 407 пъти.

За всички които имат мерак да се научат как да поправят форума като се чупи но не им се четат дебели книги - едно образователно клипче:

#108947 (ツ) palavrov
Създадено на 11.06.2024, видяно: 320 пъти.

И цял канал в тубата с едно напористо моме ...

https://www.youtube.com/@lauriewired/videos

Закачам и едно видео ако някой има мерак да види за какво иде реч:

#108949 (ツ) synergie
Последно редактирано на 11.06.2024 от synergie, видяно: 316 пъти.

Няма да го гледам, защото страдам от енвидия(да не се бърка с измисления синдром дисвидия) и вярвам в думите на чичкото с коженото яке че програмирането е умряла работа.

#108951 (ツ) palavrov
Създадено на 11.06.2024, видяно: 306 пъти.

За по засуканите работи си трябва човек. Особено ако си по близо до желязото. Също и гоненето на бъгове. Оптимизирането за някакви ограничения.

Това моме прави доста добра комбинация от асемблер, дизасемблиране и високо ниво. Чак се учудвам, че на такова младо момиче в днешно време и е интересно това с което сме започнали през 80-те ... по скоро има някой дъртак/чичак зад кадър който подготвя темите и снима а момата е главната героиня и чете сценария.

#108963 (ツ) palavrov
Последно редактирано на 12.06.2024 от palavrov, видяно: 287 пъти.
#108967 (ツ) BIGBUGEX
Създадено на 12.06.2024, видяно: 269 пъти.

Аз лично не съм запознат с арм ис. Жуля х86 и х64.

#108968 (ツ) palavrov
Последно редактирано на 12.06.2024 от palavrov, видяно: 268 пъти.
BIGBUGEX

Аз лично не съм запознат с арм ис. Жуля х86 и х64.

По приятен е. Класическия АРМ е проектиран не от чип дизайнери ами от програмисти които пишат на асм и като са сложили още от начало правилните основи и до момента си е ОК при все развитие през годините. Отделно имаш условно изпълнение на всяка инструкция, което позволява да се пише много сбит и функционален код без преходи т.е. инвалидиране на кеш, пайплине и т.н. Това се е получило защото оригинално инструкциите са по 32 бита и в тях не е проблем да се заделят 4 бита за условно изпълнение и да останат достатъчно битове за самата инструкция, регистри, че и константи. Затови постнах на това моме клипчето с алгоритъма на Евклид - това е каноничния пример за ефективността на АРМ асемблера.

Опа, момата явно не го познава като хората условното изпълнение и алгоритъма го прави като на х86 асемблер.

Те тук е обяснено както трябва - http://www.cburch.com/books/arm/

C кода:


    a = 40;
    b = 25;
    while (a != b) {
        if (a > b) a -= b;
        else       b -= a;
    }

на АРМ32 става те това:

        MOV R0, #40      ; R0 is a
        MOV R1, #25      ; R1 is b
again   CMP R0, R1
        SUBGT R0, R0, R1
        SUBLT R1, R1, R0
        BNE again
halt    B halt
#108981 (ツ) BIGBUGEX
Създадено на 12.06.2024, видяно: 245 пъти.

На х86 е малко по-дълго, но това е специфичен случай за да блесне арм.

	mov	eax,40
	mov	ecx,25
	jmp	@f

align 8
@@:
	mov	edx,eax
	mov	ebx,ecx
	sub	eax,ecx
	cmovc	eax,edx
	sub	ecx,edx
	cmovc	ecx,ebx
	cmp	eax,ecx
	jne	@b
#108984 (ツ) palavrov
Създадено на 12.06.2024, видяно: 241 пъти.
BIGBUGEX

На х86 е малко по-дълго, но това е специфичен случай за да блесне арм.

	mov	eax,40
	mov	ecx,25
	jmp	@f

align 8
@@:
	mov	edx,eax
	mov	ebx,ecx
	sub	eax,ecx
	cmovc	eax,edx
	sub	ecx,edx
	cmovc	ecx,ebx
	cmp	eax,ecx
	jne	@b

Няма спор, но примера е перфектен да се покаже мощта на условното изпълнение на инструкции. Модерните компилатори го ползва и генерират много сбит branchless код. Като добавиш и произволния shift на единия операнд или константа и става муцка.

cmovc го има като инструкция чак от P6 т.е. Pentium Pro и при това тогава не се е поддържал от всички процесори и повечето програми не са го ползвали за да са съвместими с по старите процесори които се задържаха още едно 5-10 години след това. АРМ32 си ги има условните инструкции още от чертожната маса '82-83 ... това му е хубавото на АРМ - мислен е от програмисти измъчени да пишат на асемблер за 6502 и да броят цикли на всяка инструкция - затова са направили ИСА която да става и за писане на ръка на асемблер и да е подходящ и за компилатор на езици от високо ниво.

#108988 (ツ) BIGBUGEX
Създадено на 12.06.2024, видяно: 230 пъти.

Малко по-дълго е без cmov. Ако искаме да върви и на 386:

	mov	eax,40
	mov	ecx,25

@@:	mov	edx,eax
	mov	ebx,ecx
	sub	eax,ecx
	sbb	esi,esi
	and	esi,ecx
	add	eax,esi
	sub	ecx,edx
	sbb	esi,esi
	and	esi,edx
	add	ecx,esi
	cmp	eax,ecx
	jne	@b

Но е добре да се разширява кръгозора. За сега няма алтернатива на векторните операции(авх256) при х86/х64. На арм са достъпни само екземпляри със 128 битови вектори. Поне до колкото ми е известно.

#108989 (ツ) palavrov
Последно редактирано на 12.06.2024 от palavrov, видяно: 228 пъти.
BIGBUGEX

Малко по-дълго е без cmov. Ако искаме да върви и на 386:

	mov	eax,40
	mov	ecx,25

@@:	mov	edx,eax
	mov	ebx,ecx
	sub	eax,ecx
	sbb	esi,esi
	and	esi,ecx
	add	eax,esi
	sub	ecx,edx
	sbb	esi,esi
	and	esi,edx
	add	ecx,esi
	cmp	eax,ecx
	jne	@b

Но е добре да се разширява кръгозора. За сега няма алтернатива на векторните операции(авх256) при х86/х64. На арм са достъпни само екземпляри със 128 битови вектори. Поне до колкото ми е известно.

Ти ли го написа или го крадна от някъде?

Тези хватки с sbb reg, reg или neg и т.н. са си висш пилотаж и малко хора ги ползват. Докато пишех на АСМ бях цар на такива хватки, сега съм ги позабравил вече.

Най яката ми хватка беше като писах една защита от дебъгване с exe компресор - започваше с iret защото стека го бях нагласил да има адрес на следващата инструкция и флагове за забрана на прекъсвания и т.н. Т.е. още от тук разните дизасемблери вече са спънати, че не знаят къде е следващата инструкция - която беше навряна в операнд на друга. Абе красота. Естествено бях си написал дебъгер който нямаше проблем с тези хватки. Нито като някой му прихване INT1 и INT3 т.е. прекъсванията за дебъгване. Голямо диване бях навремето. Жалко, че не сме се познавали с Жонката онези години.

Другата мизерия дето бях направил беше, че на int 1 бях закачил код който заменя адреса за връщане с един регистър т.е. по този начин инструкциите се разпределят на две места и може да правиш преходи като пипаш в този регистър - май беше BP.

После ми се скапа харда и всички сорсове заминаха 😕

#108990 (ツ) palavrov
Създадено на 12.06.2024, видяно: 225 пъти.
BIGBUGEX

За сега няма алтернатива на векторните операции(авх256) при х86/х64. На арм са достъпни само екземпляри със 128 битови вектори. Поне до колкото ми е известно.

Има. Ама не е в нормалния процесор ами е в GPU-то - CUDA

#108997 (ツ) BIGBUGEX
Последно редактирано на 12.06.2024 от BIGBUGEX, видяно: 214 пъти.
palavrov

Ти ли го написа или го крадна от някъде?

Тези хватки с sbb reg, reg или neg и т.н. са си висш пилотаж и малко хора ги ползват. Докато пишех на АСМ бях цар на такива хватки, сега съм ги позабравил вече.

Най яката ми хватка беше като писах една защита от дебъгване с exe компресор - започваше с iret защото стека го бях нагласил да има адрес на следващата инструкция и флагове за забрана на прекъсвания и т.н. Т.е. още от тук разните дизасемблери вече са спънати, че не знаят къде е следващата инструкция - която беше навряна в операнд на друга. Абе красота. Естествено бях си написал дебъгер който нямаше проблем с тези хватки. Нито като някой му прихване INT1 и INT3 т.е. прекъсванията за дебъгване. Голямо диване бях навремето. Жалко, че не сме се познавали с Жонката онези години.

Другата мизерия дето бях направил беше, че на int 1 бях закачил код който заменя адреса за връщане с един регистър т.е. по този начин инструкциите се разпределят на две места и може да правиш преходи като пипаш в този регистър - май беше BP.

После ми се скапа харда и всички сорсове заминаха 😕

Тази стратегия със sbb съм я открил по времето когато условните преходи бяха архивраг. Ползвам я много отдавна. Стигнах сам до тази схема да се ползва като маска. Виж, опкодовете не ги помня на изуст. Но гледам да съм в крак с х86/х64 инструкциите.

Има. Ама не е в нормалния процесор ами е в GPU-то - CUDA

Така и не можах да схвана логиката как се изпълняват тези куди и опенцли.

ПС: Иначе, последната схема с която се гордея е да ползвам авх256 за имплементиране на суич/кейс. Ако кейсовете са 16 битови имаме 16 тествания на операция.

format PE64 console

entry main

section ".code" code readable executable

macro wswitch wkey {
	common
	local switchID
	
	wswitch.ID equ switchID
	
	macro case key \{
		\local caseID
		switchID#.case equ caseID
		caseID\#.key equ key
		
		.\#caseID\#.def:
	\}
	
	macro default \{
		case
	\}
	
	macro break \{
		jmp .#switchID#.continue
	\}
	
	macro end.switch \{
		vpbroadcastw	ymm0,wkey
		mov	rcx,.#switchID#.keys
		
		@@:
		vpcmpeqw	ymm1,ymm0,[rcx]
		vpcmpeqw	ymm2,ymm0,[rcx + 0x20]
		vpackuswb	ymm1,ymm2,ymm1
		vpermq	ymm1,ymm1,11011000b
		vpmovmskb	edx,ymm1
		lzcnt	eax,edx
		test	edx,edx
		jnz	@f
		add	rcx,0x40
		cmp	rcx,.#switchID#.keys.end
		jb	@b
		jmp	.#switchID#.default
		
		align	4
		@@:
		lea	rcx,[rcx + rax * 2 - .#switchID#.keys]
		cmp	rcx,.#switchID#.keys.end - .#switchID#.keys
		jae	.#switchID#.default
		jmp	qword[.#switchID#.entry + rcx * 4]
		
		switchID#.mac
		jmp	.#switchID#.continue
		
		align 64
		.#switchID#.keys:
		irpv caseid, switchID#.case \\{
			if caseid\\#.key eq
				.#switchID#.default = .\\#caseid\\#.def
			else
				dw caseid\\#.key
			end if
		\\}
		if .#switchID#.default eq
			.#switchID#.default = .#switchID#.continue
		end if
		.#switchID#.keys.end:
		
		align 64
		.#switchID#.entry:
		irpv caseid, switchID#.case \\{
			if ~caseid\\#.key eq
				dq .\\#caseid\\#.def
			end if
		\\}
		.#switchID#.entry.end:
		align 64
		
		purge case
		purge default
		purge break
		purge end.switch
		.#switchID#.continue:
	\}
	macro switchID#.mac
}

main:
	wswitch [test0]
	{case 1
		mov	ebx,1
		break
	case 2
	case 3
	case 4
	case 5
	case 6
	case 7
	case 10
		wswitch [test1]
		\{case 0
		case 1
		case 3
		default
		\}end.switch
		break
	default
	}end.switch

section ".data" data writeable
test0	dw 10
test1	dw 3

section ".import" import data readable
#108999 (ツ) palavrov
Последно редактирано на 12.06.2024 от palavrov, видяно: 188 пъти.

Човек, от 20 години не съм писал на асемблер и бая съм ръждясал вече. Останах си на ниво асмблер за дос. Тези векторни инструкции така са ми на китайски. Вложените макроси и те.

sbb reg,reg и т.н. ги научих с дебъгване. Някои компилатори така правеха abs, sign т.е. - 1,0,1 според знака и т.н. И то после логично може да ги комбинираш и да правиш каквото си искаш без преходи.

#109001 (ツ) palavrov
Създадено на 12.06.2024, видяно: 177 пъти.

А за опкодовете - от толкова гледане на дизасемблер на времето ги бях научил. АСКИ таблицата още я знам.

Най интересното беше защо на 8080 инструкция за CALL и на 8086 инструкцията за прекъсване INT са с един и същи опкод. Защото Интел като са пускали 8086 са решили за по евтино да преизползват периферията за 8080 и там котнролера за прекъсвания 8259 (ако не бъркам) като стане прекъсване поема шината за данни и подава на процесора байтовете на инструкция за call до съответния адрес на прекъсването. А за 8086 се подава INT XX. И за по лесно са ползвали един и също опкод за двата режима - 0xCD

#109123 (ツ) BIGBUGEX
Създадено на 14.06.2024, видяно: 132 пъти.

В примера ми без cmov има една излишна инструкция. Оставям някой майстор да го оправи.

Assembly
0

AsmBB v3.0 (check-in: a316dab8b98d07d9); SQLite v3.42.0 (check-in: 831d0fb2836b71c9);
©2016..2023 John Found; Licensed under EUPL. Powered by Assembly language Created with Fresh IDE