Результаты поиска

Это вопрос систем низкого уровня.

Мне нужно смешать 32-битный и 16-битный код, потому что я пытаюсь вернуться в реальный режим из защищенного режима. Как немного справочной информации, мой код делает это сразу после загрузки GRUB, поэтому у меня нет какой-либо надоедливой операционной системы, чтобы сказать мне, что я могу и не могу сделать.

В любом случае, я использую [BITS 32] и [BITS 16] с моим assembly, чтобы сообщить nasm, какие типы операций он должен использовать, но когда я тестирую свой код, используйте bochs, похоже, что для некоторых операций bochs не выполняет код, который я написал. Похоже, что ассемблер застрял в экстрах 0x66 и 0x67, что смущает bochs.

Итак, как я могу заставить nasm успешно собрать код, где я смешиваю 32-битный и 16-битный код в одном файле? Есть ли какой-то трюк?

Это довольно странно, но я сегодня возился с ассемблером GNU (я хочу иметь возможность хотя бы читать синтаксис) и пытался заставить этот мой маленький надуманный пример работать. А именно я просто хочу перейти от 0 к 100, все время распечатывая цифры. Поэтому через несколько минут я придумываю вот что:

# count.s: print the numbers from 0 to 100. 
    .text
string: .asciz "%d\n"
    .globl _main

_main:
    movl    $0, %eax # The starting point/current value.
    movl    $100,   %ebx # The ending point.

_loop:
    # Display the current value.
    pushl   %eax
    pushl   $string
    call     _printf
    addl     $8, %esp

    # Check against the ending value.
    cmpl    %eax, %ebx
    je    _end

    # Increment the current value.
    incl    %eax
    jmp _loop   

_end:

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

(Форматирование немного испорчено, но ничего серьезного).

Кто-нибудь знает о дизассемблере для ARMV4i исполняемых файлов и DLLs?

У меня есть плагин DLL, который я пишу с очень редким data abort (<5% временем), который я сузил до конкретной функции (через dumpbin и вывод адреса data abort). Однако это довольно большая функция, и я хотел бы немного сузить ее. Я знаю, что это происходит в вызове memset() , но эта конкретная функция имеет около 35 из них, поэтому я надеялся, что, посмотрев на разборку, я смогу выяснить, где на самом деле находится проблема.

Я бы хотел научиться программировать на ассемблере. Я уже делал немного assembly раньше (во время моего курса вычислений уровня А), но это было очень определенно упрощенное 'pseudo-assembler'. Я позаимствовал у своего отца старый справочник по ассемблеру Z80, и это кажется довольно интересным, поэтому, если возможно, я хотел бы попробовать использовать Z80 assembler.

Однако у меня нет процессора Z80 под рукой, и я хотел бы сделать это на моем PC (у меня есть windows или linux, так что либо хорошо). Я нашел различные ассемблеры в интернете, но я не особенно заинтересован в сборке до файла hex, я хочу просто иметь возможность собрать его до чего-то, что может запустить какой-то симулятор на PC. Желательно, чтобы этот тренажер показывал мне содержимое всех регистров, ячеек памяти и т. д.,и позволял мне выполнять инструкции. Я нашел несколько битов программного обеспечения, которые предполагают, что они могут это сделать, но они либо отказываются компилироваться, либо, похоже, не работают должным образом. У кого-нибудь есть какие-нибудь предложения? Если есть хороший симулятор / IDE вещей, доступных для другого типа ассемблера, то я мог бы попробовать это вместо этого (предполагая, что есть хороший онлайн справочник доступен).

Мои цели сосредоточены на разработке программного обеспечения и, возможно, разработке веб-приложений, но, скорее всего, настольных приложений. Я вступаю на путь более близкого знакомства с C/C++,, но должен ли я идти гораздо ниже, чем это, в assembly? Или у меня не было бы выгоды для моих долгосрочных целей?

Фрагмент кода My C принимает адрес аргумента и сохраняет его в энергонезависимой памяти (предварительно обработанный код):

void foo(unsigned int x) {
    *(volatile unsigned int*)(0x4000000 + 0xd4) = (unsigned int)(&x);
}

int main() {
    foo(1);
    while(1);
}

Я использовал SVN версию GCC для компиляции этого кода. В конце функции foo я ожидал бы, что значение 1 будет сохранено в стеке, а в 0x40000d4-адрес , указывающий на это значение. Когда я компилирую без оптимизации, используя флаг -O0, я получаю ожидаемый выход ARM7TMDI assembly (прокомментированный для вашего удобства):

        .align  2
        .global foo
        .type   foo, %function
foo:
        @ Function supports interworking.
        @ args = 0, pretend = 0, frame = 8
        @ frame_needed = 0, uses_anonymous_args = 0
        @ link register save eliminated.
        sub     sp, sp, #8
        str     r0, [sp, #4]     @ 3. Store the argument on the stack
        mov     r3, #67108864
        add     r3, r3, #212
        add     r2, sp, #4       @ 4. Address of the stack variable
        str     r2, [r3, #0]     @ 5. Store the address at 0x40000d4
        add     sp, sp, #8
        bx      lr
        .size   foo, .-foo
        .align  2
        .global main
        .type   main, %function
main:
        @ Function supports interworking.
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 0, uses_anonymous_args = 0
        stmfd   sp!, {r4, lr}
        mov     r0, #1           @ 1. Pass the argument in register 0
        bl      foo              @ 2. Call function foo
.L4:
        b       .L4
        .size   main, .-main
        .ident  "GCC: (GNU) 4.4.0 20080820 (experimental)"

Он четко сохраняет аргумент сначала в стеке, а оттуда сохраняет его в 0x40000d4 . Когда я компилирую с оптимизациями, используя -O1 , я получаю что-то неожиданное:

        .align  2
        .global foo
        .type   foo, %function
foo:
        @ Function supports interworking.
        @ args = 0, pretend = 0, frame = 8
        @ frame_needed = 0, uses_anonymous_args = 0
        @ link register save eliminated.
        sub     sp, sp, #8
        mov     r2, #67108864
        add     r3, sp, #4        @ 3. Address of *something* on the stack
        str     r3, [r2, #212]    @ 4. Store the address at 0x40000d4
        add     sp, sp, #8
        bx      lr
        .size   foo, .-foo
        .align  2
        .global main
        .type   main, %function
main:
        @ Function supports interworking.
        @ args = 0, pretend = 0, frame = 0
        @ frame_needed = 0, uses_anonymous_args = 0
        stmfd   sp!, {r4, lr}
        mov     r0, #1           @ 1. Pass the argument in register 0
        bl      foo              @ 2. Call function foo
.L4:
        b       .L4
        .size   main, .-main
        .ident  "GCC: (GNU) 4.4.0 20080820 (experimental)"

На этот раз аргумент никогда не сохраняется в стеке, даже если что- то из стека все еще хранится в 0x40000d4 .

Это просто ожидаемое / неопределенное поведение? Я сделал что-то не так или действительно нашел компилятор Bug™?