jcmvbkbc

gcc -S преподаёт отличные уроки, рекомендую!

.text
        .att_syntax
foo:
        movb    $4, %al

        .intel_syntax

        mov     %al, 4

$ gcc -c att-intel.S 
$ objdump -d att-intel.o

att-intel.o:     file format elf64-x86-64


Disassembly of section .text:

0000000000000000 <foo>:
   0:   b0 04                   mov    $0x4,%al
   2:   b0 04                   mov    $0x4,%al

Деасемблирование дало такой результат:
mov ds:0x0,al
Может мне кто-то объяснить что это значит ds:0x0

Значит что дизассемблировал что-то не то.

Пишу под Linux(Ubuntu), следовательно приходится осваивать синтаксис GAS(AT&T)

Не, не "следовательно". gas умеет как синтексис intel (.intel_syntax) так и синтаксис at&t (.att_syntax).

addb $str, i
relocation truncated to fit: R_X86_64_8 against `.data'

Потому что при сборке под 64 бита надо адресоваться относительно %rip. Если оно тебе не надо, проще собирать под 32 бита.

int $0x80

Не работает в 64-битных программах. Ну ты понел. (с)

Нужно из c++ переместить этот массив в ассемблерную вставку, а там уже перенести из этого массива в другой массив все элементы, которые равны сумме соседних.
То есть регистры e*x нельзя брать. Кто может подсказать, где найти материал по этой теме, либо же предложить пример кода для решения поставленной задачи?

Можно написать этот код так, что он не будет использовать никакие конкретные регистры явно. Конкретные регистры будут подставлены компилятором. Например (gcc):

#include <stdint.h>

void f(void)
{
    uint32_t a[16] = {1, 2, 3, 1, 5, 4, -1, }, b[16] = {0};
    void *a1, *b1;
    uint32_t tmp, cnt = 14;

    asm (
        "lea %[a], %[a1]\n\t"
        "lea %[b], %[b1]\n"
        "1:\n\t"
        "mov (%[a1]), %[tmp]\n\t"
        "add 8(%[a1]), %[tmp]\n\t"
        "cmp 4(%[a1]), %[tmp]\n\t"
        "jne 2f\n\t"
        "mov %[tmp], (%[b1])\n\t"
        "add $4, %[b1]\n"
        "2:\n\t"
        "add $4, %[a1]\n\t"
        "dec %[cnt]\n\t"
        "jnz 1b\n\t"
        : [cnt] "=&r" (cnt), [tmp] "=&r" (tmp),
          [a1] "=&r" (a1), [b1] "=&r" (b1),
          [b] "=m" (b)
        : [a] "m" (a));
}

asm (
    "mov a, %eax \n\t"
    "mov b, %ebx \n\t"
    "add %eax, %ebx \n\t"
    "mov %ebx, c \n\t"
  );

Так в gcc не работает. Должно быть например так:

asm (
    "mov %[a], %%eax \n\t"
    "mov %[b], %%ebx \n\t"
    "add %%eax, %%ebx \n\t"
    "mov %ebx, %[c] \n\t"
    : [c] "=rm" (c)
    : [a] "rm" (a), [b] "rm" (b)
    : "eax", "ebx", "cc"
  );

Что это всё значит можно почитать тут.

Компилирую, а тут фигня происходит:

Ошибка говорит о том, что код попытался обратиться к глобальному символу a, но такого символа нет. Потому что переменная a размещена на стеке и символьного имени у неё и правда нет. Если бы она (вместе с b и c) была глобальной, всё равно была бы ошибка (по крайней мере при компиляции под 64 бита), но другая.

Вот где код вырывается в память 0xfffff

Вот в конце же, после последнего nop.

Насчет компиляторов поверю, но вот процессора ??? как ???

Читать тут, лучше сразу английскую версию.

Русским и английским языком написано. Сегментные регистры в x64 кроме GS и FS не используются и принудительно устанавливаются в 0.

Это какая-то неоднозначная и неточная цитата. Вот что пишет Intel Software Developer Manual 3.7.4.1 "Segmentat...:

In 64-bit mode, segmentation is generally (but not completely) disabled, creating a flat 64-bit linear-address space. The processor treats the segment base of CS, DS, ES, SS as zero, creating a linear address that is equal to the effective address. The exceptions are the FS and GS segments, whose segment registers (which hold the segment base) can be used as additional base registers in some linear address calculations.

Т.е. базовый адрес сегментов к которым осуществляется доступ через cs/ds/es/ss нулевой, но не сами значения селекторов. Базовый адрес, напомню, это поле в записях GDT/LDT. Селектор же (значение в сегментном регистре) выбирает запрашиваемые привилегии (младшие два бита), тип таблицы (GDT/LDT, третий с конца бит) и номер записи в таблице (все остальные биты).

Согласись же, это совсем не то, что ты ожидал?

Глядя на твою картинку можно сказать, что выполняется код из сегментв в шестой записи в GDT с привилегиями третьего кольца защиты, а доступ к данным через ds/es/ss/gs осуществляется через сегмент в пятой записи в GDT с привилегиями третьего кольца.

WriteConsole не выводит текст

А что возвращает? А GetLastError какой? А что в буфере buffer и в eax перед вызовом WriteConsole?

invoke accept,[socket_server],addr_client,sizeof.sockaddr_in

accept последним параметром ожидает указатель на размер, а не сам размер.

перекомпилируйте с параметром -fPIC
gcc -fPIC ./hello.s

"перекомпилируйте" в данном контексте означает "сгенерируйте другой ассемблерный код".

Код программы выглядит так:

Ну это же явно 32-битный код, компилируй его под 32 бита:
gcc -m32 hello.s -o hello

1) Первая страница памяти отвечает за обращение к первой странице памяти вторая ко второй и так далее?

Вопрос непонятен.

2) Связка виртуального и физического адреса позволяет создать что-то по типу перенаправления?

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

3) Работает ли обратная связь когда если пишу в виртуальную страницу идет перенаправление на физическую?

Да.

4) Для работоспособности в данном режиме надо создаться страницы в диапазоне которых лежии код программы?

Как минимум исполняющийся в настоящий момент код.

5) Страничная организация памяти работает паралельно с адресацией по дискриптору или это замена?

Работает параллельно. Т.е. адрес вида сегмент:смещение сначала преобразуется в линейный адрес, который потом транслируется в физический адрес.

https://flatassembler.net/docs.php?article=fasmg говорит нам:

What is flat assembler g?
It is an assembly engine designed as a successor of the one used in flat assembler 1, one of the recognized assemblers for x86 processors. This is a bare engine that by itself has no ability to recognize and encode instructions of any processor, however it has an ability to become an assembler for any CPU architecture. It has a macroinstruction language that is substantially improved compared to the one provided by flat assembler 1 and it allows to easily implement instruction encoders in form of customizable macroinstructions. This approach has a great flexibility at the cost of performance.

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