Самомодифицирующийся код в экосистеме Cortex-M., есть ли право на жизнь? Опции

[jcxz]

Есть мысль использовать самомодифицирующийся код для оптимизации решения одной задачи.
Именно самомодифицирующийся - программа строит часть самой себя по некоему алгоритму, а не просто копирует куски кода из одной области памяти в другую.
И вот я что-то не смог вспомнить чтобы здесь на форуме вообще когда-то поднималась эта тема.
Кто-то вообще использует такой код на ARM-ах в своих проектах? Просто интересно...

PS: И пожалуйста - без религиозной нетерпимости.

[AlexandrY]

PS: И пожалуйста - без религиозной нетерпимости.

Обещать не могу.

А загрузчики считаются самомодифицирующимся кодом?
Или самомодифицирующийся - это код который вот именно сам себя модифицирует, т.е. инструкция STR вот прямо по своему адресу что-то и пишет и сама себя таким образом затирает.

[jcxz]

Или самомодифицирующийся - это код который вот именно сам себя модифицирует, т.е. инструкция STR вот прямо по своему адресу что-то и пишет и сама себя таким образом затирает.

Я уже выше написал: будет функция, которая по некоторым условиям пишет другую функцию. По командам. В маш.кодах. Команды записываемые в тело создаваемой функции (и их последовательность) зависят от аргументов первой функции.

PS: Вот уже сколько откликов получил, а на собственно единственный вопрос, поставленный в первом сообщении, так никто и не ответил. И видимо забыли все в чём был вопрос.....
Вопрос был собственно в том: использовал кто-нить из здесь присутствующих самомодифицирующийся код (именно такой код, который или сам своё тело правит или строит другой код (а не просто копирует из одного места в другое))? Именно на платформе ARM в embedded?
И, если использовали, то для какой задачи?

[AlexandrY]

Я уже выше написал: будет функция, которая по некоторым условиям пишет другую функцию. По командам. В маш.кодах. Команды записываемые в тело создаваемой функции (и их последовательность) зависят от аргументов первой функции.

Тогда я не согласен с названием "самомодифицирующийся", у меня загрузчики тоже загружают разные не то что функции, а целые программы(и да в машинных кодах, разумеется) в зависимости от аргументов.

[Николай Семёнови...]

Тогда я не согласен с названием "самомодифицирующийся", у меня загрузчики тоже загружают разные не то что функции, а целые программы(и да в машинных кодах, разумеется) в зависимости от аргументов.

Попытаюсь объяснить (как я это понял), что подразумевать под "самомодифицирующимся кодом" топикстартер.

Не.

Не буду. Боюсь всё равно не поймёте
А разжигать холивар не хочу

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

[jcxz]

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

Вот именно. Даже полностью строит процедуру. Вот такой примерно должен быть результат (код) работы генератора:

CODE

;Назначение регистров в динамически генерируемой функции.
dstReg EQU c_R0 ;указатель на целевой буфер для записи (вх.аргумент)
tblReg EQU c_R1 ;указатель на таблицу адресов переменных (вх.аргумент)
tmpReg0 EQU c_R2 ;рабочий регистр 0
tmpReg1 EQU c_R3 ;рабочий регистр 1
;сама функция
;f0 LDR tmpReg0, [tblReg, #bit1*4]; где bit1 - номер первого единичного бита в мл.слове бит-карты
;f0 LDR tmpReg1, [tblReg, #bit2*4]; где bit2 - номер второго единичного бита в мл.слове бит-карты
;f1 LDR/LDRH tmpReg0, [tmpReg0]
;f2 STR/STRH tmpReg0, [dstReg], #step; где step==4 для STR и step==2 для STRH
;f0 LDR tmpReg0, [tblReg, #bit3*4]; где bit3 - номер 3-го единичного бита в мл.слове бит-карты
;f1 LDR/LDRH tmpReg1, [tmpReg1]
;f2 STR/STRH tmpReg1, [dstReg], #step; где step==4 для STR и step==2 для STRH
;f0 LDR tmpReg1, [tblReg, #bit4*4]; где bit4 - номер 4-го единичного бита в мл.слове бит-карты
;f1 LDR/LDRH tmpReg0, [tmpReg0]
;f2 STR/STRH tmpReg0, [dstReg], #step; где step==4 для STR и step==2 для STRH
; ...
;f3 ADDS tblReg, tblReg, #32*4; вставляется при переходе к ст.слову бит-карты если в нём есть единицы
;f0 LDR tmpReg0, [tblReg, #bit1*4]; где bit1 - номер 1-го единичного бита в ст.слове бит-карты
;f1 LDR/LDRH tmpReg1, [tmpReg1]
;f2 STR/STRH tmpReg1, [dstReg], #step; где step==4 для STR и step==2 для STRH
;f0 LDR tmpReg1, [tblReg, #bit2*4]; где bit2 - номер 2-го единичного бита в ст.слове бит-карты
;f1 LDR/LDRH tmpReg0, [tmpReg0]
;f2 STR/STRH tmpReg0, [dstReg], #step; где step==4 для STR и step==2 для STRH
; ...
;f1 LDR/LDRH tmpReg1, [tmpReg1]
;f2 STR/STRH tmpReg1, [dstReg], #step; где step==4 для STR и step==2 для STRH
;f4 BX LR

LDR или LDRH использовать - определяется весом бита, заданным в таблице. Генератор формирует код глядя в эту таблицу.

Как видно, в любом случае нет больше в цикле инструкций проверки условий в if(...)-ах (а они же ведь по сути Bxx в ассемблерном представлении) (да и куда лучше вовсе не проверять заранее ложные условия по списку), а выполняются только нужные инструкции сразу, как будто условных конструкций и нет. А п. 1 и 2, конечно, требуют тактов, только для моего случая п. 1. требуется выполнить только 1 раз для всех итераций цикла, на этапе составления списка инструкций СМК.
Надеюсь, моя мысль будет так понятнее.

Блин, коллега, позвольте пожать Вашу руку! Вы - похоже почти единственный человек на этом форуме сходу понявший все нюансы!!!

Я просто телепат

Как будто заглянули в мои исходники!

[Arlleex]

Блин, коллега, позвольте пожать Вашу руку! Вы - похоже почти единственный человек на этом форуме сходу понявший все нюансы!!!

О результатах сообщите, пожалуйста, удалось/не удалось внедрить, буду держать на всякий случай идею такую. Я довольно плотно поработал с битовой графикой на LCD/TFT дисплеях и организовывал меню разной степени вложенности для пользователей устройств с тачскрином/кнопками и экраном. Там таких ситуаций, где флажки надо опрашивать и определять отрисовки, да на каждом шагу по 50

[jcxz]

О результатах сообщите, пожалуйста, удалось/не удалось внедрить, буду держать на всякий случай идею такую. Я довольно плотно поработал с битовой графикой на LCD/TFT дисплеях и организовывал меню разной степени вложенности для пользователей устройств с тачскрином/кнопками и экраном. Там таких ситуаций, где флажки надо опрашивать и определять отрисовки, да на каждом шагу по 50

Ок. Генератор написал, но отлаживать буду завтра - поздно уже. Как заработает - напишу.
У меня этот код предназначен для записи текущих значений переменных в поток. Карта выбранных для записи переменных приходит по интерфейсу связи и может меняться в процессе работы иногда, не прерывая процесса. Всего в программе много десятков таких переменных, которые хотелось бы писать, но писать все сразу - не хватит пропускной способности канала.
Переменные пока только 16- и 32-битные (целочисленные и float). Каждая битовая позиция в карте закреплена жёстко за какой-то переменной. И есть таблица указателей на эти переменные.
И это только - сервисная задача. Её выполнение не должно мешать выполнению основных рабочих задач МК, которых достаточно много и тяжёлых. Но в процессе работы нужно следить за всеми этими переменными.
Вот примерно так.

[adnega]

Как заработает - напишу.

Проверил в железе - работает (Cortex-M0).

CODE

#include "stdafx.h"
#include "conio.h"
#include "windows.h"

#define IS_ALIGN (1)
#define VAR_NUM (32)

//-----------------------------------------------------------------------------
// enum eVAR_TYPE
//-----------------------------------------------------------------------------
enum eVAR_TYPE
{
VAR_NONE = 0,
VAR_DWORD,
VAR_WORD,
VAR_BYTE,
};

//-----------------------------------------------------------------------------
// typedef struct sVAR
//-----------------------------------------------------------------------------
typedef struct sVAR
{
union
{
DWORD data_dw;
WORD data_w;
BYTE data_b;
};
enum eVAR_TYPE type;
} sVAR;

volatile sVAR var[VAR_NUM] =
{
{0x12345678, VAR_DWORD},
{0xABCD, VAR_WORD},
{0x11223344, VAR_DWORD},
{0x55, VAR_BYTE},
{0x00, VAR_BYTE},
{0x66, VAR_BYTE},
{0x77, VAR_BYTE},
{0x88, VAR_BYTE},
{0x99, VAR_BYTE},
{0xAA, VAR_BYTE},
{0xBB, VAR_BYTE},
{0xCC, VAR_BYTE},
{0xDD, VAR_BYTE},
{0xEE, VAR_BYTE},
{0xFF, VAR_BYTE},
{0x98765432, VAR_DWORD},
};

BYTE exec_ram[1024];

//-----------------------------------------------------------------------------
// void set_new_mask(const DWORD mask)
//-----------------------------------------------------------------------------
void set_new_mask(const DWORD mask)
{
int offset;
int last_var = 0;
int s_pos = 0;
int exec_ram_pos = 0;

printf("// r0 = *s, r1 = var\n");

// PUSH {r2, lr}
exec_ram[exec_ram_pos++] = 0x04;
exec_ram[exec_ram_pos++] = 0xB5;

printf("B5 04 - push {r2, pc}\n");

for(int i = 0; i < VAR_NUM; i++)
{
if(mask & (1 << i))
{
switch(var[i].type)
{
case VAR_DWORD:
printf("// DWORD[%d]\n", i);

offset = (i - last_var) * 8;
last_var = i;

while(offset > 128)
{
offset -= 128;
// ADD r1, #128
exec_ram[exec_ram_pos++] = 128;
exec_ram[exec_ram_pos++] = 0x31;

printf("31 80 - add r1, #128\n");
}

if(offset)
{
// ADD r1, #offset
exec_ram[exec_ram_pos++] = offset;
exec_ram[exec_ram_pos++] = 0x31;

printf("31 %02X - add r1, #%d\n", offset, offset);
}

if(IS_ALIGN && (s_pos & 1))
{
// byte align

// LDRB r2, [r1, #0]
exec_ram[exec_ram_pos++] = 0x0A;
exec_ram[exec_ram_pos++] = 0x78;

printf("78 0A - ldrb r2, [r1, #0]\n");

// STRB r2, [r0, #0]
exec_ram[exec_ram_pos++] = 0x02;
exec_ram[exec_ram_pos++] = 0x70;

printf("70 02 - strb r2, [r0, #0]\n");

// LDRB r2, [r1, #1]
exec_ram[exec_ram_pos++] = 0x4A;
exec_ram[exec_ram_pos++] = 0x78;

printf("78 4A - ldrb r2, [r1, #1]\n");

// STRB r2, [r0, #1]
exec_ram[exec_ram_pos++] = 0x42;
exec_ram[exec_ram_pos++] = 0x70;

printf("70 42 - strb r2, [r0, #1]\n");

// LDRB r2, [r1, #2]
exec_ram[exec_ram_pos++] = 0x8A;
exec_ram[exec_ram_pos++] = 0x78;

printf("78 8A - ldrb r2, [r1, #2]\n");

// STRB r2, [r0, #2]
exec_ram[exec_ram_pos++] = 0x82;
exec_ram[exec_ram_pos++] = 0x70;

printf("70 82 - strb r2, [r0, #2]\n");

// LDRB r2, [r1, #3]
exec_ram[exec_ram_pos++] = 0xCA;
exec_ram[exec_ram_pos++] = 0x78;

printf("78 CA - ldrb r2, [r1, #3]\n");

// STRB r2, [r0, #3]
exec_ram[exec_ram_pos++] = 0xC2;
exec_ram[exec_ram_pos++] = 0x70;

printf("70 C2 - strb r2, [r0, #3]\n");
}
else if(IS_ALIGN && (s_pos & 2))
{
// word align

// LDRH r2, [r1, #0]
exec_ram[exec_ram_pos++] = 0x0A;
exec_ram[exec_ram_pos++] = 0x88;

printf("88 0A - ldrh r2, [r1, #0]\n");

// STRH r2, [r0, #0]
exec_ram[exec_ram_pos++] = 0x02;
exec_ram[exec_ram_pos++] = 0x80;

printf("80 02 - strh r2, [r0, #0]\n");

// LDRH r2, [r1, #2]
exec_ram[exec_ram_pos++] = 0x4A;
exec_ram[exec_ram_pos++] = 0x88;

printf("88 4A - ldrh r2, [r1, #2]\n");

// STRH r2, [r0, #2]
exec_ram[exec_ram_pos++] = 0x42;
exec_ram[exec_ram_pos++] = 0x80;

printf("80 42 - strh r2, [r0, #2]\n");
}
else
{
// dword align

// LDR r2, [r1, #0]
exec_ram[exec_ram_pos++] = 0x0A;
exec_ram[exec_ram_pos++] = 0x68;

printf("68 0A - ldr r2, [r1, #0]\n");

// STR r2, [r0, #0]
exec_ram[exec_ram_pos++] = 0x02;
exec_ram[exec_ram_pos++] = 0x60;

printf("60 02 - str r2, [r0, #0]\n");
}

// ADDS r0, #4
exec_ram[exec_ram_pos++] = 0x04;
exec_ram[exec_ram_pos++] = 0x30;

printf("30 04 - adds r0, #4\n");

s_pos += 4;
break;

case VAR_WORD:
printf("// WORD[%d]\n", i);

offset = (i - last_var) * 8;
last_var = i;

while(offset > 128)
{
offset -= 128;
// ADD r1, #128
exec_ram[exec_ram_pos++] = 128;
exec_ram[exec_ram_pos++] = 0x31;

printf("31 80 - add r1, #128\n");
}

if(offset)
{
// ADD r1, #offset
exec_ram[exec_ram_pos++] = offset;
exec_ram[exec_ram_pos++] = 0x31;

printf("31 %02X - add r1, #%d\n", offset, offset);
}

if(IS_ALIGN && (s_pos & 1))
{
// byte align

// LDRB r2, [r1, #0]
exec_ram[exec_ram_pos++] = 0x0A;
exec_ram[exec_ram_pos++] = 0x78;

printf("78 0A - ldrb r2, [r1, #0]\n");

// STRB r2, [r0, #0]
exec_ram[exec_ram_pos++] = 0x02;
exec_ram[exec_ram_pos++] = 0x70;

printf("70 02 - strb r2, [r0, #0]\n");

// LDRB r2, [r1, #1]
exec_ram[exec_ram_pos++] = 0x4A;
exec_ram[exec_ram_pos++] = 0x78;

printf("78 4A - ldrb r2, [r1, #1]\n");

// STRB r2, [r0, #1]
exec_ram[exec_ram_pos++] = 0x42;
exec_ram[exec_ram_pos++] = 0x70;

printf("70 42 - strb r2, [r0, #1]\n");
}
else
{
// word align

// LDRH r2, [r1, #0]
exec_ram[exec_ram_pos++] = 0x0A;
exec_ram[exec_ram_pos++] = 0x88;

printf("88 0A - ldrh r2, [r1, #0]\n");

// STRH r2, [r0, #0]
exec_ram[exec_ram_pos++] = 0x02;
exec_ram[exec_ram_pos++] = 0x80;

printf("80 02 - strh r2, [r0, #0]\n");
}

// ADDS r0, #2
exec_ram[exec_ram_pos++] = 0x02;
exec_ram[exec_ram_pos++] = 0x30;

printf("30 02 - adds r0, #2\n");

s_pos += 2;
break;

case VAR_BYTE:
printf("// BYTE[%d]\n", i);

offset = (i - last_var) * 8;
last_var = i;

while(offset > 128)
{
offset -= 128;
// ADD r1, #128
exec_ram[exec_ram_pos++] = 128;
exec_ram[exec_ram_pos++] = 0x31;

printf("31 80 - add r1, #128\n\r");
}

if(offset)
{
// ADD r1, #offset
exec_ram[exec_ram_pos++] = offset;
exec_ram[exec_ram_pos++] = 0x31;

printf("31 %02X - add r1, #%d\n", offset, offset);
}

// LDRB r2, [r1, #0]
exec_ram[exec_ram_pos++] = 0x0A;
exec_ram[exec_ram_pos++] = 0x78;

printf("78 0A - ldrb r2, [r1, #0]\n");

// STRB r2, [r0, #0]
exec_ram[exec_ram_pos++] = 0x02;
exec_ram[exec_ram_pos++] = 0x70;

printf("70 02 - strb r2, [r0, #0]\n");

// ADDS r0, #1
exec_ram[exec_ram_pos++] = 0x01;
exec_ram[exec_ram_pos++] = 0x30;

printf("30 01 - adds r0, #1\n");

s_pos += 1;
break;
}
}
}
printf("// EXIT\n");

// POP {r2, pc}
exec_ram[exec_ram_pos++] = 0x04;
exec_ram[exec_ram_pos++] = 0xBD;

printf("BD 04 - pop {r2, pc}\n");

#if 0
printf("SMC:\n");
for(int i = 0; i < exec_ram_pos / 2; i++)
printf("%02X %02X\n", exec_ram[i * 2 + 1], exec_ram[i * 2 + 0]);
#endif
}

int _tmain(int argc, _TCHAR* argv[])
{
set_new_mask(0xc7);
_getch();
return 0;
}

СМК:

CODE

// r0 = *s, r1 = var
B5 04 - push {r2, pc}
// DWORD[0]
68 0A - ldr r2, [r1, #0]
60 02 - str r2, [r0, #0]
30 04 - adds r0, #4
// WORD[1]
31 08 - add r1, #8
88 0A - ldrh r2, [r1, #0]
80 02 - strh r2, [r0, #0]
30 02 - adds r0, #2
// DWORD[2]
31 08 - add r1, #8
88 0A - ldrh r2, [r1, #0]
80 02 - strh r2, [r0, #0]
88 4A - ldrh r2, [r1, #2]
80 42 - strh r2, [r0, #2]
30 04 - adds r0, #4
// BYTE[6]
31 20 - add r1, #32
78 0A - ldrb r2, [r1, #0]
70 02 - strb r2, [r0, #0]
30 01 - adds r0, #1
// BYTE[7]
31 08 - add r1, #8
78 0A - ldrb r2, [r1, #0]
70 02 - strb r2, [r0, #0]
30 01 - adds r0, #1
// EXIT
BD 04 - pop {r2, pc}

Результат на Cortex-M0

RESULT[20000F44]: 78 56 34 12 CD AB 44 33 22 11 77 88

[jcxz]

Проверил в железе - работает (Cortex-M0).

мммм... неправильно
См. моё сообщение #39 - какой должен быть результат работы.
К тому же: a) const в аргументе set_new_mask() - лишнее; б) R2,LR в вашей функции - не нужно сохранять, см. соглашения вызова компилятора; в) даже по Вашему алгоритму копирования - очень неоптимально, количество команд в 2 раза больше, чем можно было бы (для Cortex-M4).

[adnega]

мммм... неправильно

А что именно неправильно?
Есть таблица переменных состоящая из значений и типов.
Есть маска, где каждый бит связан с соответствующим элементом таблицы.
Есть функция-генератор, создающая в рантайме код, при выполнении которого
в выходной поток копируются данные из таблицы с учетом длины и заданной маски.
Для заданного var, RESULT (отработал СМК) такой ожидаете?
Если нет, то где ошибка?

a) const в аргументе set_new_mask() - лишнее;

Ну, функция set_new_mask не должна менять mask, поэтому и const. Или я вас не понял.

б) R2,LR в вашей функции - не нужно сохранять, см. соглашения вызова компилятора;

Вы же супер-скорость хотели. Выкидывайте push и pop - и вот вам готовый участок кода, дающий результат,
но не забудьте проинициализировать r0 и r1.
Если нужна именно как функция, то достаточно одного "bx lr" в конце.

в) даже по Вашему алгоритму копирования - очень неоптимально, количество команд в 2 раза больше, чем можно было бы (для Cortex-M4).

Какие именно команды лишние? Можно IS_ALIGN обнулить, тогда генератор будет работать с невыровненными данными.
Попробую сегодня избавиться от лишних adds.

[jcxz]

А что именно неправильно?
Есть таблица переменных состоящая из значений и типов.

Вы же ассемблер понимаете? Тогда посмотрите на требуемый результат (код) в сообщении #39 и поймёте в чём разница.
Нет таблицы переменных, есть таблица указателей на переменные. Так как эти переменные разбросаны по всей программе и объединить их в одну область памяти (структуру) нельзя. Они находятся в разных обособленных службах программы, и там и должны оставаться. А адресация их идёт через таблицу указателей. Я писал об этом. И в примере результата это чётко видно.
Если си-исходник будет понятней, то:

CODE

enum {N = <максимум 64>};
enum {TYP_s16, TYP_u16, TYP_s32, TYP_u32, TYP_float, TYP_n};
struct {
u8 main:3;
u8 misc:5;
} const isTyp[N] = {{TYP_s32, ...}, {TYP_u16, ...}, ...};
u8 isTypSize[TYP_n] = {2, 2, 4, 4, 4};
char *psrc;
char *pdst;
if (map & 1 << 0) {
psrc = varPtrs[0];
if (isTypSize[isTyp[0].main]) == 4) {
*(u32 *)pdst = *(u32 *)psrc;
pdst += 4;
} else {
*(u16 *)pdst = *(u16 *)psrc;
pdst += 2;
}
}
if (map & 1 << 1) {
psrc = varPtrs[1];
if (isTypSize[isTyp[1].main]) == 4) {
*(u32 *)pdst = *(u32 *)psrc;
pdst += 4;
} else {
*(u16 *)pdst = *(u16 *)psrc;
pdst += 2;
}
}
//и так далее... так сейчас в си-исходнике сделано. Цель СМК - построить оптимальный код выкинув кучу ненужных операций из этого алгоритма по текущей карте map, до следующего её изменения.

Какие именно команды лишние? Можно IS_ALIGN обнулить, тогда генератор будет работать с невыровненными данными.
Попробую сегодня избавиться от лишних adds.

У меня Cortex-M4. Он поддерживает команды с пост- и пре- модификациями адреса. Например: LDR R0, [R1], #4 тогда ваш код сократится в 2 раза.
Да я уже вчера всё сделал. И даже больше. Мой генератор ещё и перемежение команд поддерживает для исключения штрафов между командами LDR.
И я его на асме написал. Хотя это просто из спортивного интереса.

[adnega]

Да я уже вчера всё сделал

Покажите пожалуйста выход генератора для случая DWORD, WORD, DWORD, BYTE, BYTE в виде asm-инструкций.
У меня с таблицей переменных и невыровненными данным получилось так

CODE

// r0 = *s, r1 = var
// DWORD[0]
68 0A - ldr r2, [r1, #0]
60 02 - str r2, [r0, #0]
// WORD[1]
89 0A - ldrh r2, [r1, #8]
80 82 - strh r2, [r0, #4]
// DWORD[2]
8A 0A - ldrh r2, [r1, #16]
80 C2 - strh r2, [r0, #6]
8A 4A - ldrh r2, [r1, #18]
81 02 - strh r2, [r0, #8]
// BYTE[6]
31 30 - add r1, #48
78 0A - ldrb r2, [r1, #0]
72 82 - strb r2, [r0, #10]
// BYTE[7]
7A 0A - ldrb r2, [r1, #8]
72 C2 - strb r2, [r0, #11]
30 0C - adds r0, #12
47 70 - bx lr

Кста, а есть у кого-нить справочник машинных кодов для Cortex-M всех семейств?
Не путать со справочником asm-команд, который найти не составляет труда.

[jcxz]

Покажите пожалуйста выход генератора для случая DWORD, WORD, DWORD, BYTE, BYTE в виде asm-инструкций.

Да, как только поборю IAR. Если у Вас IAR, то как Вы ему сказали, чтобы он массив объявленный в программе как массив, показывал в окне дизасма как код? А то у меня он, собака, как только видит что это массив, показывает просто как кучу констант DC32 как этот массив не объявляй. Не могу заставить его дизассемблировать (((
И мне не нужны байтовые операции - переменные только 16 и 32 бита.

Кста, а есть у кого-нить справочник машинных кодов для Cortex-M всех семейств?

Мне тоже хотелось-бы. Не нашёл в инете. Только если правильно выражаться: таблица маш.кодов набора инструкций Thumb-2.

Господа, вы тут явно пытаетесь эмулировать DMA.

Да причём тут DMA??? Каким боком он поможет в этой задаче? Разве чтобы только затормозить процедуру в несколько раз?

Более простое название этого процесса - полиморфный код.

Мне без разницы как это называть. Пускай будет полиморфный.
А что именно требуется - мне кажется уже каждый должен был понять, хоть немного почитав тред.

[adnega]

Да, как только поборю IAR.

gcc-шный objdump легко превращает бинарник в s-файл.
Можете скинуть бинарь - я его конвертну, если у вас нет gcc.

[jcxz]

Можете скинуть бинарь - я его конвертну, если у вас нет gcc.

Спасибо, уже не надо - просто копировал из массива результат в неиспользуемую память МК, а для такой памяти IAR позволяет делать дизасм. Так и отладил.
Вобщем: всё ок работает алгоритм.
Ниже прикладываю результат его работы для 64-битного слова: 0000.002A.1003.0006.
При таких весах битов карты (см. установленные биты в бит-карте выше):
бит1=2 байта, бит2=2 байта, бит16=4 байта, бит17=2 байта, бит28=4 байта, бит33=4 байта, бит35=4 байта, бит37=2 байта.

Результат картинкой (не знаю как в IAR сохранить текстовое содержимое окна дизасма, а InqSoft Scaner не захватывает текст из этого окна):

А здесь результат в бинарнике:
 smk00.zip ( 233 байт ) Кол-во скачиваний: 4

Итого - время выполнения этого кода думаю будет == примерно 31 такт (не измерял), при условии что dst на входе - выровнен на 4.
Как можно догадаться: функция строится таким образом, чтобы она была определена как:
extern "C" void * Func(void *dst, u32 *table);
где: dst - буфер для записи (передаётся в R0); table - массив из 64-х указателей на захватываемые переменные.

Скопирует все переменные в одну область и вышлет куда надо.
Или даже без копирования вышлет.

Ну-ну. А теперь объясните как он это скопирует, когда переменные разбросаны по всей памяти МК кусочками по 2 и по 4 байта?
Про передачу свЯзными списками я в курсе.

[AlexandrY]

Ну-ну. А теперь объясните как он это скопирует, когда переменные разбросаны по всей памяти МК кусочками по 2 и по 4 байта?
Про передачу свЯзными списками я в курсе.

И чем не подошла передача связными списками?