Структура данных для ассемблерного кода? [исследование]

Это возможно. Динамическая генерация кода является даже господствующей тенденцией в некоторых областях как рендеринг программного обеспечения и графика. Вы находите большое использование во всех видах языков сценария в динамической компиляции байт-кода в машинном коде (.NET, Java, насколько я знаю Perl. Недавно JavaScript вступил в члены клуба также).

Вы также находите, что это использовало в очень тяжелых математикой приложениях также, Это имеет значение, если Вы, например, удаляете все умножение с нулем из умножения матриц, если Вы планируете сделать такое умножение несколько тысяч раз.

Я настоятельно рекомендую, что Вы читаете на представлении SSA кода. Это - представление, где каждый примитив превращен в так называемые три формы операнда, и каждая переменная только присвоена однажды (следовательно та же Статическая форма Однократного присвоения).

Можно возрасти оптимизация порядка на таком коде, и это является прямым для превращения того кода в исполняемый код. Вы не запишете что бэкенд генерации кода в выходные хотя...

Получить чувство, как SSA похож на Вас, может испытать компилятор LLVM. На их веб-сайте у них есть немного, "Испытывают" виджет для проигрывания с. Вы вставляете код C в окно, и Вы получаете что-то, которое является близко к форме SSA.

Мало примера, как это похоже:

Позволяет берут этот целочисленный алгоритм квадратного корня в C. (произвольный пример, я просто взял что-то простое, все же нетривиальное):

unsigned int isqrt32 (unsigned int value) 
{
    unsigned int g = 0;
    unsigned int bshift = 15;
    unsigned int b = 1<<bshift;
    do {
        unsigned int temp = (g+g+b)<<bshift;
        if (value >= temp) {
            g += b;
            value -= temp;
        }
        b>>=1;
    } while (bshift--);
    return g;
}

LLVM поворачивает его в:

define i32 @isqrt32(i32 %value) nounwind  {
entry:
    br label %bb

bb:     ; preds = %bb, %entry
    %indvar = phi i32 [ 0, %entry ], [ %indvar.next, %bb ]      
    %b.0 = phi i32 [ 32768, %entry ], [ %tmp23, %bb ]
    %g.1 = phi i32 [ 0, %entry ], [ %g.0, %bb ]     
    %value_addr.1 = phi i32 [ %value, %entry ], [ %value_addr.0, %bb ]      
    %bshift.0 = sub i32 15, %indvar 
    %tmp5 = shl i32 %g.1, 1 
    %tmp7 = add i32 %tmp5, %b.0 
    %tmp9 = shl i32 %tmp7, %bshift.0    
    %tmp12 = icmp ult i32 %value_addr.1, %tmp9      
    %tmp17 = select i1 %tmp12, i32 0, i32 %b.0      
    %g.0 = add i32 %tmp17, %g.1     
    %tmp20 = select i1 %tmp12, i32 0, i32 %tmp9     
    %value_addr.0 = sub i32 %value_addr.1, %tmp20           
    %tmp23 = lshr i32 %b.0, 1       
    %indvar.next = add i32 %indvar, 1       
    %exitcond = icmp eq i32 %indvar.next, 16    
    br i1 %exitcond, label %bb30, label %bb

bb30:       ; preds = %bb
    ret i32 %g.0
}

Я знаю, что это выглядит ужасным сначала. Это даже не чистая SSA-форма. Чем больше Вы читаете на том представлении, тем больше смысла оно будет иметь. И Вы также узнаете, почему это представление так широко используется эти дни.

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

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

Это - очень хорошая и интересная область исследования.

Править: И прежде чем я забываю это: не пропускайте созданный в функциях.NET и Java. Эти languates позволяют Вам компилировать из байт-кода или исходного кода из программы и выполнять результат.

С наилучшими пожеланиями, ноли

Относительно Вашего редактирования: Как выполнить двоичный блоб с кодом:

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

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

Можно использовать этот тупик для начала работы:

typedef void (* voidfunc) (void);

void * generate_code (void)
{
    // reserve some space
    unsigned char * buffer = (unsigned char *) malloc (1024);


    // write a single RET-instruction
    buffer[0] = 0xc3; 

    return buffer;
}

int main (int argc, char **args)
{
    // generate some code:
    voidfunc func = (voidfunc) generate_code();

    // flush instruction cache:
    FlushInstructionCache(GetCurrentProcess(), func, 1024);

    // execute the code (it does nothing atm)
    func();

    // free memory and exit.
    free (func);
}

Я предполагаю, что Вы хотите, чтобы структура данных содержала некоторый шаблон инструкции, вероятно, проанализированный из существующего машинного кода, подобного:

add r1, r2, <int>

У Вас будет массив этой структуры, и Вы выполните некоторую оптимизацию на этом массиве, вероятно, изменяя его размер или создавая новый, и генерируете соответствующий машинный код.

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

Проверьте Молнию GNU. Это может быть полезно для Вас.

В 99% случаев разница в производительности незначительна. Основное преимущество классов состоит в том, что код, произведенный ООП, лучше и легче понять, чем процессуальный кодекс.

Я не уверен, в каком языке Вы кодируете - отмечают, что в C# существенное различие между классами и структурами - то, что структуры являются типами значения, в то время как классы являются ссылочными типами. В этом случае Вы могли бы хотеть запуститься со структур, но все еще добавить поведение (конструктор, методы) им.

Обсуждение технического значения оптимизирует себя, Ваш код, в коде C++, выбирающем между структурой POD или полным объектом, является главным образом точкой инкапсуляции.

Встраивание кода позволит компилятору оптимизировать (или не), конструкторы/средства доступа использовали. Не будет никакой потери производительности.

Во-первых, установите конструктора

Если Вы работаете с компилятором C++, создаете по крайней мере одного конструктора:

struct asm_code {
   asm_code()
      : type(0), value(0), optimized(0) {}

   asm_code(int type_, int value_, int optimized_)
      : type(type_), value(value_), optimized(_optimized) {}

   int type;
   int value;
   int optimized;
 };

По крайней мере, у Вас не будет неопределенных структур в Вашем коде.

Действительно ли каждая комбинация данных возможна?

Используя структуру как Вы использование означает, что любой тип возможен с любым значением и любым оптимизированным. Например, если я установил тип = 25, значение = 1205 и оптимизировал =-500, затем это в порядке.

Если Вы не хотите, чтобы пользователь поместил случайные значения в Вашей структуре, добавьте встроенные средства доступа:

struct asm_code {

   int getType() { return type ; }
   void setType(int type_) { VERIFY_TYPE(type_) ; type = type_ ; }

   // Etc.

   private :
      int type;
      int value;
      int optimized;
 };

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