Тра­дици­онно под воз­вра­щаемым фун­кци­ей зна­чени­ем понима­ется то, что переда­ет опе­ратор return. Одна­ко это лишь над­водная часть айсбер­га, не рас­кры­вающая всей кар­тины вза­имо­дей­ствия фун­кций друг с дру­гом. В качес­тве наг­лядной демонс­тра­ции рас­смот­рим типич­ный при­мер, в котором про­исхо­дит воз­вра­щение зна­чения в аргу­мен­те, передан­ном по ссыл­ке:

Фун­кция xdiv воз­вра­щает резуль­тат целочис­ленно­го деления аргу­мен­та а на аргу­мент b, но, помимо это­го, она записы­вает оста­ток в перемен­ную с, передан­ную по ссыл­ке. Так сколь­ко же зна­чений вер­нула фун­кция? И чем воз­вра­щение резуль­тата по ссыл­ке хуже или «незакон­нее» клас­сичес­кого return?

По­пуляр­ные изда­ния склон­ны упро­щать проб­лему иден­тифика­ции воз­вра­щен­ного фун­кци­ей зна­чения, рас­смат­ривая один лишь час­тный слу­чай с опе­рато­ром return.

Мы же рас­смот­рим сле­дующие механиз­мы:

• воз­врат зна­чения опе­рато­ром return;
  


• воз­врат зна­чений через аргу­мен­ты, передан­ные по ссыл­ке;
  


• воз­врат зна­чений через динами­чес­кую память (кучу);
  


• воз­врат зна­чений через гло­баль­ные перемен­ные;
  


• воз­врат зна­чений через фла­ги про­цес­сора.
  

Во­обще‑то к это­му спис­ку не помеша­ло бы добавить воз­врат зна­чений через дис­ковые и про­еци­руемые в память фай­лы, но это выходит за рам­ки обсужда­емой темы (хотя, рас­смат­ривая фун­кцию как «чер­ный ящик» с вхо­дом и выходом, нель­зя не приз­нать, что вывод фун­кци­ей резуль­татов сво­ей работы в файл фак­тичес­ки и есть воз­вра­щаемое ею зна­чение).

Возврат значения оператором return

По общепри­нято­му сог­лашению на плат­форме x86-64 зна­чение, воз­вра­щаемое опе­рато­ром return, помеща­ется в регистр RAX (в EAX в 32-раз­рядном режиме). Вещес­твен­ные типы (float, double) — в регистр XMM0.

А как воз­вра­щают­ся типы, занима­ющие более 8 байт? Ска­жем, некая фун­кция воз­вра­щает струк­туру, сос­тоящую из сотен бай­тов, или объ­ект сопос­тавимо­го раз­мера. Ни то ни дру­гое в регис­тры не запих­нешь!

Ока­зыва­ется, если воз­вра­щаемое зна­чение не может быть втис­нуто в регис­тры, ком­пилятор скры­то от прог­раммис­та переда­ет фун­кции неяв­ный аргу­мент — ссыл­ку на локаль­ную перемен­ную, в которую и записы­вает­ся воз­вра­щен­ный резуль­тат. Таким обра­зом, фун­кции mystuct MyFunc(int a, int b) и void MyFunc(mystryct *my, int a, int b) ком­пилиру­ются в иден­тичный (или близ­кий к тому) код, из‑за чего «вытянуть» из машин­ного кода под­линный про­тотип невоз­можно!

Да­вай про­верим наши пред­положе­ния. Откомпи­лируй сле­дующий код с отклю­чен­ной опти­миза­цией в Visual C++:

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

На сле­дующей иллюс­тра­ции я при­вел обе фун­кции для срав­нения в одном окне VS Code.

Хо­тя по объ­ему фун­кции раз­лича­ются, выпол­няемые ими дей­ствия схо­жи. И без отла­доч­ной информа­ции понять их раз­личия неп­росто. Меж­ду тем, если приг­лядеть­ся, мож­но обна­ружить явные намеки, в какой фун­кции про­исхо­дит работа над ссы­лоч­ным типом, а где выпол­няет­ся воз­врат по зна­чению. Смот­ри:

В начале фун­кции зна­чения копиру­ются из регис­тров в память. Вид­но, что пер­вый аргу­мент целочис­ленный. Мож­но пред­положить, что это ука­затель на струк­туру. Осталь­ные аргу­мен­ты переда­ются в регис­трах XMM*, сле­дова­тель­но, пред­став­ляют чис­ла с пла­вающей запятой. Пос­ле откры­тия кад­ра сте­ка зна­чения раз­меща­ются в смеж­ных областях памяти, это может ука­зывать, что они при­над­лежат обще­му кон­тей­неру (струк­туре, мас­сиву).

Да­лее копиру­ется 24 бай­та (0x18) или 192 бита (0xC0). Если это чис­ло раз­делить на три, получим 64 бита (0x40). Что и тре­бова­лось доказать: один эле­мент double — это 64 бита, а в струк­туре их три. Пред­послед­ним дей­стви­ем помеща­ем ука­затель на струк­туру в RAX, в который будет воз­вра­щен резуль­тат. Пос­ледним дей­стви­ем зак­рыва­ем кадр сте­ка. В ито­ге нап­рашива­ется вывод, что здесь про­исхо­дит воз­врат зна­чения. Сле­дова­тель­но, про­тотип фун­кции выг­лядит так:

Раз­берем дизас­сем­блер­ный лис­тинг вто­рой фун­кции.

На­чало такое же, как в прош­лый раз. Но в этой фун­кции не откры­вает­ся кадр сте­ка, что может ука­зывать на работу с сущес­тву­ющей струк­турой. Далее одно за дру­гим выпол­няет­ся замеще­ние зна­чений полей струк­туры. В кон­це фун­кция ничего не воз­вра­щает. Отсю­да мож­но вывес­ти такой про­тотип:

Нам уда­лось опре­делить раз­личия фун­кций толь­ко пос­ле их глу­боко­го ана­лиза. Теперь взгля­нем на самоде­ятель­ность ком­пилято­ра C++Builder.

В этом слу­чае при бег­лом взгля­де раз­ница сов­сем незамет­на. В обе­их фун­кци­ях при­сутс­тву­ет кадр сте­ка. Меж­ду тем и здесь есть зацеп­ка: пос­ле откры­тия кад­ра сте­ка толь­ко в MyFunc1 содер­жимое регис­тра RCX копиру­ется в RAX. А в пер­вом по логике вещей находит­ся целочис­ленное зна­чение или ука­затель. Так­же в MyFunc1 перед зак­рыти­ем кад­ра сте­ка ука­затель на область памяти RBP+var_20 копиру­ется в регистр RAX явно для воз­вра­та резуль­тата, сле­дова­тель­но, эта фун­кция име­ет такой про­тотип:

Определение типа возвращаемого значения

Тип воз­вра­щаемо­го зна­чения мож­но приб­лизитель­но опре­делить по раз­меру регис­тра, в котором он воз­вра­щает­ся. Если воз­вра­щаемое зна­чение помеща­ется в EAX, мож­но пред­положить, что воз­вра­щает­ся int, float или дру­гой четырех­бай­товый тип. Не исклю­чен вари­ант воз­вра­та мень­шего типа, нап­ример char. Так­же для воз­вра­та одно­бай­товых типов может быть исполь­зован регистр AL или AX. В пос­леднем может быть воз­вра­щено двух­бай­товое зна­чение. Вось­мибай­товые типы воз­вра­щают­ся в регис­тре RAX, при этом ник­то не зап­реща­ет ком­пилято­ру вер­нуть в нем зна­чение более мел­кого типа, тут уж как повезет. На 64-бит­ной плат­форме это основное средс­тво воз­вра­та зна­чения из фун­кции.

Ес­ли фун­кция при выходе явно прис­ваивает одно­му из перечис­ленных выше регис­тров некото­рое зна­чение, зна­чит, оно воз­вра­щает­ся в вызыва­ющую фун­кцию. Если же эти регис­тры оста­ются неоп­ределен­ными, то, ско­рее все­го, воз­вра­щает­ся тип void, то есть нич­то. Уточ­нить информа­цию помога­ет ана­лиз вызыва­ющей фун­кции, а точ­нее, то, как она обра­щает­ся с регис­тра­ми RAX [EAX]. Логич­но пред­положить: если вызыва­ющая фун­кция не исполь­зует зна­чения, оставлен­ного вызыва­емой фун­кци­ей в регис­трах RAX [EAX], ее тип — void. Но это пред­положе­ние не всег­да вер­но. Час­тень­ко прог­раммис­ты игно­риру­ют воз­вра­щаемое зна­чение, вво­дя иссле­дова­телей в заб­лужде­ние.

Для зак­репле­ния изу­чен­ного рас­смот­рим сле­дующий при­мер, демонс­три­рующий механизм воз­вра­щения основных типов зна­чений:

Ре­зуль­тат его ком­пиляции в Microsoft Visual C++ 2019 с отклю­чен­ной опти­миза­цией будет выг­лядеть так:

Из памяти оба зна­чения копиру­ются в 32-бит­ные регис­тры. Вмес­те с тем они пре­обра­зуют­ся из типа char в int.

Сло­жение зна­чений, находя­щих­ся в регис­трах. Сум­ма накап­лива­ется в регис­тре EAX. В нем так­же выпол­няет­ся воз­врат резуль­тата в выз­вавшую фун­кцию.

К сожале­нию, дос­товер­но опре­делить тип воз­вра­щаемо­го зна­чения невоз­можно. Он с рав­ным успе­хом может пред­став­лять собой int и char, при­чем int даже более веро­ятен, так как сум­ма двух char по сооб­ражени­ям безопас­ности дол­жна помещать­ся в int, ина­че воз­можно перепол­нение.

Ко­пиро­вание в регистр EAX сум­мы, которая будет воз­вра­щена. По всей веро­ятности, тип воз­вра­щаемо­го зна­чения — int.

Сле­дова­тель­но, воз­вра­щаемый тип име­ет раз­мер 64 бита, то есть int64, что и тре­бова­лось доказать.

Сле­дующий вити­ева­тый код исполь­зует­ся, что­бы опре­делить сме­щение внут­ри мас­сива. Стоп! Но у нас же нет никако­го мас­сива. А как же стро­ка c[0] = a[0] + b[0];? Получа­ется аж три мас­сива, ведь ком­пилятор обра­баты­вает ука­зате­ли как мас­сивы и наобо­рот.

Вы­зыва­ем фун­кцию char_func(1,2). Как мы пом­ним, у нас были сом­нения в типе воз­вра­щаемо­го ею зна­чения: либо int, либо char.

Рас­ширя­ем воз­вра­щен­ное фун­кци­ей зна­чение до signed int, сле­дова­тель­но, она воз­вра­тила signed char.

Пре­обра­зуем двой­ное сло­во, содер­жаще­еся в регис­тре EAX, в чет­верное, помеща­емое в регистр RAX. Это говорит о том, что тип воз­вра­щен­ного фун­кци­ей зна­чения пре­обра­зует­ся из int в int64. Пока непонят­но, для чего и зачем.

Вы­зыва­ем фун­кцию int64_func(5,6), воз­вра­щающую тип int64. Теперь ста­новит­ся понят­но, чем выз­вано рас­ширение пре­дыду­щего резуль­тата.

Для переда­чи в качес­тве парамет­ров заг­ружа­ем в регис­тры RDX и RCX ука­зате­ли на перемен­ные b и a, зна­чения которых опре­деле­ны в начале фун­кции.

Как мы видим, в иден­тифика­ции типа зна­чения, воз­вра­щен­ного опе­рато­ром return, ничего хит­рого нет, все про­заич­но. Но не будем спе­шить. Рас­смот­рим сле­дующий при­мер, демонс­три­рующий воз­вра­щение струк­туры по зна­чению. Как ты дума­ешь, что имен­но и в каких регис­трах будет воз­вра­щать­ся?

Вни­мание! Не запус­кай откомпи­лиро­ван­ную прог­рамму. Мало того что она содер­жит ошиб­ку (в буфер вмес­тимостью четыре сим­вола помеща­ется стро­ка раз­мером в 14 сим­волов), так еще некото­рые анти­виру­сы счи­тают такую прог­рамму мал­варью.