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

В соответствии с x64 software conventions будем считать что число подлежащие конвертированию расположено в XMM0.

Будем использовать x64 битный код при x32 битной адресации. Такой способ адресации позволяет использовать преимущества обоих диалектов.

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

	; старт процедуры
	mov    r9d, esp
	lea    r8d,[r9d - 70h]
	and    r8d, 0FFFFFFF0h
	mov    esp, r8d

Подготавливаем FPU освобождая его от данных и устанавливаем повышенную точность и округление к нулю:

	fsave [esp]
	finit
	mov  dword ptr[esp - dword], 037F0F7Fh
	fldcw         [esp - dword]

Перегружаем число из XMM0 в FPU:

	movd qword ptr[esp - xmmword], xmm0
	fld  qword ptr[esp - xmmword]

Находим десятичный порядок Числа:

	fld     st(0)
	fxtract
	fldl2t
	fst     st(1)
	fdivr   st(0),st(2)
	frndint

Устанавливаем округление к ближайшему числу:

	fldcw	[esp - word]

Сохраняем порядок Числа и находим десятичный порядок Множителя для перевода значащих цифр Числа в целую часть:

	fist      dword ptr[esp - dword]
	movzx edx, word ptr[esp - dword]
	mov       dword ptr[esp - dword], 10h
	fisubr    dword ptr[esp - dword]

Находим десятичный Множитель и перемножаем его на Число:

	fmulp   st(1),st(0)
	fst     st(1)
	frndint
	fsub    st(1),st(0)
	fld1
	fscale
	fstp    st(1)
	fmulp   st(2),st(0)
	f2xm1
	fld1
	faddp   st(1),st(0)
	fmulp   st(1),st(0)
	frndint

Перегружаем полученное число из FPU в регистры AX и XMM0 в размере 2 первых и 8 последующих байтов соответственно. При загрузки 8 байт в регистр XMM0 одновременно меняем порядок расстановки байт за счет предварительного выравнивания указателя стека по параграфу:

	fbstp           tbyte ptr[esp - xmmword]
	mov       ax,    word ptr[esp -   qword]
	pshuflw xmm0, xmmword ptr[esp - xmmword], 00011011b

Восстанавливаем состояние FPU:

	frstor [esp]

Переставляем байты регистра ХММ0 до состояния их полного разворота с одновременным удвоением:

	punpcklbw xmm0, xmm0
	pshuflw   xmm0, xmm0, 10110001b
	pshufhw   xmm0, xmm0, 10110001b

Загружаем маску и разделяем числовые тетрады:

	mov            dword ptr[esp], 0FF00FF0h
	pshufd xmm1, xmmword ptr[esp], 0
	pand   xmm0, xmm1
	psrlw  xmm1, 4
	movdqa xmm2, xmm1
	pand   xmm1, xmm0
	psrlw  xmm1, 4
	pandn  xmm2, xmm0
	paddb  xmm1, xmm2

Создаем маску и находим байты содержащие значащие цифры:

	pxor    xmm0, xmm0
	pcmpeqb xmm0, xmm1

Преобразуем числа в соответствующие им символы:

	mov            dword ptr[esp], 30303030h
	pshufd xmm2, xmmword ptr[esp], 0
	paddb  xmm1, xmm2

Преобразуем первые два байта числа в символы и сохраняем их в память:

	mov  byte ptr[esp],'-'
	btr             ax, 0Fh
	adc            esp, 0
	add             ax,'.0'
	mov  word ptr[esp], ax

Находим длину значащей части числа в регистре ХММ0 :

	movdqu	      xmmword ptr[esp + word], xmm1
	pmovmskb ecx, xmm0
	bsf      ecx, ecx
	add      esp, ecx

Проверка порядка Числа на нулевое значение и отрицательную величину:

	mov    ecx,(word + dword)
	mov    eax, edx
	neg     dx
	jnc     @f
	cmovns eax, edx
	setns   dh

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

	cmp   ax, 0Ah
	sbb  ecx, ecx
	mov   dl, 0Ah
	div   dl
	cmp   al, 0Ah
	sbb  ecx, 0
	shl  eax, 8
	shr   ax, 8
	div   dl
	add eax, 303030h
	lea edx,[edx * 2 + 2B51h]
	
	mov dword ptr[esp + word + ecx + word], eax
	mov  word ptr[esp + word], dx

Вычисляем длину числа и сохраняем ее в регистрах EAX и ECX:

@@:	lea ecx,[esp + ecx + qword]
	sub ecx, r8d
  mov eax,ecx

Сохраняем строку символов в паре регистров XMM1 и XMM2:

	movdqa xmm1, xmmword ptr[r8d]
	movdqa xmm2, xmmword ptr[r8d + xmmword]

Восстанавливаем значение стека:

	mov esp, r9d

Выходим из процедуры.

В своем коде я применяю недокументированное соглашение о передаче / возврате из функции множественных параметров. Соглашение абсолютно зеркально соглашению x64 software conventions за тем исключением что описывает правила размещения параметров при выходе из процедуры.

Зачем писать этот код если уже есть готовые решения - потому что мое решение лучше.

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

Зачем писать его на ассемблере если есть другие более удобные языки - потому что ассемблер лучше.

Чем ассемблер лучше в данном случае - полным доступом к SIMD и FPU командам.

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