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

Ответ 1

Использование регистров CPU для передачи аргументов выполняется быстрее, чем использование памяти, то есть стека. Однако в ЦПУ имеется ограниченное количество регистров (особенно в x86-совместимых ЦП), поэтому, когда функция имеет много параметров, тогда стек используется вместо регистров процессора. В вашем случае есть 5 аргументов функции, поэтому компилятор использует стек для аргументов вместо регистров.

В принципе, компиляторы могут использовать push команды для толкания аргументов для стека до фактического call функции, но многие компиляторы (включая gnu c++) используют mov для толкания аргументов для стека. Этот способ удобен, так как он не изменяет регистр ESP (верхняя часть стека) в части кода, вызывающей функцию.

В случае, если значения passByValue(i, c, p, f, tc) помещаются в стек. Вы можете увидеть много команд mov из ячейки памяти в регистр и из регистра в соответствующее место стека. Причиной этого является то, что сборка x86 запрещает прямое перемещение из одного места памяти в другое (исключение - movs который перемещает значения из одного массива (или строки по вашему желанию) в другой).

В случае passByReference(i, c, p, f, tc) вы можете увидеть много инструкций 5 lea, которые копируют адреса аргументов в регистры CPU, и эти значения регистров переносятся в стек.

Случай passByPointer(&i, &c, &p, &f, &tc) аналогичен passByValue(i, c, p, f, tc). Внутри, на уровне сборки, по ссылке используются указатели, а на более высоком уровне c++, программисту не нужно явно использовать операторы & и * для ссылок.

После того, как параметры перемещаются в стек, выдается call, который подталкивает указатель инструкции EIP к стеку перед передачей выполнения программы в подпрограмму. Все moves параметров к учетной записи стека для следующего EIP в стеке после команды call.

Ответ 2

Там слишком много в вашем примере выше, чтобы вскрыть все из них. Вместо этого я просто passByValue поскольку это кажется самым интересным. Впоследствии вы должны быть в состоянии выяснить остальное.

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

• Нет никаких инструкций по прямой копированию данных из одного места памяти в другое место памяти. например. mov [ebp - 44], [ebp - 36] не является юридической инструкцией. Для хранения данных сначала требуется промежуточный регистр, а затем копируется в память.
• Оператор скобки [] в сочетании с средством mov для доступа к данным из вычисленного адреса памяти. Это аналогично дешифрованию указателя в C/C++.
• Когда вы видите lea x, [y] который обычно означает вычисляемый адрес y и сохраняет в x. Это аналогично адресу адреса переменной в C/C++.
• Данные и объекты, которые необходимо скопировать, но слишком велики, чтобы вписаться в регистр, копируются в стек в куклу. IOW, он скопирует собственное машинное слово за раз, пока не будут скопированы все байты, представляющие объект/данные. Обычно это означает, что 4 или 8 байтов на современных процессорах.
• Компилятор обычно будет чередовать инструкции вместе, чтобы поддерживать занятость в процессоре и минимизировать киоски. Хорошо для эффективности кода, но плохо, если вы пытаетесь понять разборку.

С учетом вышеизложенного вызов функции passByValue перестраивается немного, чтобы сделать его более понятным:

.define arg1  esp
.define arg2  esp + 4
.define arg3  esp + 8
.define arg4  esp + 12
.define arg5.1  esp + 16
.define arg5.2  esp + 20


; copy first parameter
mov EAX, [EBP - 16]
mov [arg1], EAX

; copy second parameter
mov DL, [EBP - 17]
movsx   EAX, DL
mov [arg2], EAX

; copy third
mov ECX, [EBP - 24]
mov [arg3], ECX

; copy fourth
movss   XMM0, DWORD PTR [EBP - 28]
movss   DWORD PTR [arg4], XMM0

; intermediate copy of TestClass?
mov ESI, [EBP - 40]
mov [EBP - 48], ESI
mov ESI, [EBP - 36]
mov [EBP - 44], ESI

;copy fifth
lea ESI, [EBP - 48]
mov EAX, [ESI]
mov [arg5.1], EAX
mov EAX, [ESI + 4]
mov [arg5.2], EAX
call    passByValue(int, char, int*, float, TestClass)

Вышеприведенный код не имеет отношения, а смещение команд отменено, чтобы дать понять, что на самом деле происходит, но некоторые все еще требуют объяснения. Во-первых, символ signed и имеет размер по одному байту. Инструкции здесь:

; copy second parameter
mov DL, [EBP - 17]
movsx   EAX, DL
mov [arg2], EAX

читает байт из [ebp - 17] (где-то в стеке) и сохраняет его в младший первый байт edx. Этот байт затем копируется в eax с помощью расширенного перемещения. Полное 32-битное значение в eax, наконец, копируется в стек, доступ к passByValue может получить passByValue. Если вам нужна более подробная информация, см. Схему реестров.

Четвертый аргумент:

movss   XMM0, DWORD PTR [EBP - 28]
movss   DWORD PTR [arg4], XMM0

Использует команду SSE movss для копирования значения с плавающей точкой из стека в регистр xmm0. Вкратце, инструкции SSE позволяют выполнять одну и ту же операцию на нескольких фрагментах данных одновременно, но здесь компилятор использует ее как промежуточное хранилище для копирования значений с плавающей запятой в стеке.

Последний аргумент:

; copy intermediate copy of TestClass?
mov ESI, [EBP - 40]
mov [EBP - 48], ESI
mov ESI, [EBP - 36]
mov [EBP - 44], ESI

соответствует TestClass. По-видимому, этот класс имеет размер 8 байтов, расположенный в стеке от [ebp - 40] до [ebp - 33]. Класс здесь копируется по 4 байта за раз, так как объект не может вписаться в один регистр.

Вот что выглядит примерно так: перед call passByValue:

lower addr    esp       =>  int:arg1            <--.
              esp + 4       char:arg2              |
              esp + 8       int*:arg3              |    copies passed
              esp + 12      float:arg4             |    to 'passByValue'
              esp + 16      TestClass:arg5.1       |
              esp + 20      TestClass:arg5.2    <--.
              ...
              ...
              ebp - 48      TestClass:arg5.1    <--   intermediate copy of 
              ebp - 44      TestClass:arg5.2    <--   TestClass?
              ebp - 40      original TestClass:arg5.1
              ebp - 36      original TestClass:arg5.2
              ...
              ebp - 28      original arg4     <--.
              ebp - 24      original arg3        |  original (local?) variables
              ebp - 20      original arg2        |  from calling function
              ebp - 16      original arg1     <--.
              ...
higher addr   ebp           prev frame

Ответ 3

То, что вы ищете, - это соглашения ABI. Различные платформы имеют разные соглашения. например, Windows на x86-64 имеет разные соглашения, чем Unix/Linux на x86-64.

http://www.agner.org/optimize/ имеет документ-соглашения о вызовах, описывающий различные для x86/amd64.

Вы можете писать код в ASM, который делает все, что угодно, но если вы хотите вызвать другие функции и вызываться ими, тогда передайте параметры/возвращаемые значения в соответствии с ABI.

Полезно было бы использовать вспомогательную функцию внутреннего использования, которая не использует стандартный ABI, но вместо этого использует значения в регистрах, которые вызывающая функция выделяет в них. Это esp. вероятно, если вы пишете основную программу в чем-то, отличном от ASM, с небольшой частью в ASM. Тогда часть asm должна заботиться только о том, чтобы быть переносимой в системы с различными ABI для вызова из основной программы, а не для собственных внутренних компонентов.