4. Ram Speicher auführen

Ram Speicher auführen

  • R

    SpR schrieb:

    ich will ja ebx in den Wert von eax schreiben deswegen glaube ich schon das es nicht wichtig ist ob dies ne gültige addresse ist: 100h

    Oh doch!

    Also, ich habe das Ganze unter Windows getestet, und es funktioniert. Sowohl "mov ebx, 100h" als auch "mov ebx, dword [100h]" werden von FASM anstandslos kompiliert, letzteres produziert beim Ausführen unter Windows allerdings einen Absturz, da der Speicher bei 0x00000100 nicht zum Lesen freigegeben ist. Ersteres funktioniert wie gewünscht. Allerdings bereitet mir ein bisschen Sorge, dass der auf dem Stack liegende Wert über DS geändert wird.

    Deine Angaben sind einigermaßen verwirrend:

    1. Welches Betriebssystem, welcher Compiler?
    2. Was zum Donnerwetter heißt "Diese Datei lade ich ... in den Ram"?
    3. Woher weißt Du, dass die Funktion und der Rücksprung richtig ausgeführt werden?
    4. "nen Fehler" ist unter Umständen etwas ungenau.
    5. Wenigstens Deklaration und Aufruf der Funktion hättest Du mitteilen können.

    viele grüße
    ralph

    0
  • ?

    Hmm also ich habe asm größenteils über inline Assembler geübt , da ich Windows 7 habe und daher die Hardware Interrupts nicht mehr möglich sind benutze ich Assembler nur zum optimieren einiger C++ Funktionen. Ich rufe die Funktion wie Folgt auf( im C++ Programm mit inline asm):

    lea eax,MeineVariableDerenWertGeändertWerdenSoll
push eax
call MeineFunktion

    So rufe ich die Funktion im Programm auf!

    _MyFunc:
push ebp
mov ebp,esp
mov eax,[ebp+8]
mov ebx,dword[100h]
mov [eax],ebx
pop ebp
ret

    Der Plan war in eax die Addresse der Variablen zu "bekommen". Nun wollte ich da dies nicht geht:

    _MyFunc:
push ebp
mov ebp,esp
mov eax,[ebp+8]
mov [eax],100h
pop ebp
ret

    Das einzige was diese Funktion machen soll ist den Wert der Variablen deren Addresse ich übergeben habe zu verändern

    0
  • ?

    Dies macht Fasm aus meiner Funbktion:
    00030000 55 push ebp
    00030001 66 89 E5 mov bp,sp
    00030004 67 66 8B 45 08 mov ax,word ptr [di+8]
    00030009 66 BB 64 00 mov bx,64h
    0003000D 00 00 add byte ptr [eax],al
    0003000F 67 66 01 18 add word ptr [bx+si],bx
    00030013 66 5D pop bp
    00030015 C3 ret

    0
  • ?

    Das hier ist das Problem:

    00030000 89 E8            mov         eax,ebp 
00030002 66 50            push        ax

    In eax sthet jz die richtige Größe also die Größe von ebp allerdings macht fasm ax daraus... in ax steht nur ein Teil der Addresse und da ist das Problem..
    Hätte einer von euch ne Idee , das fasm den Code nicht entfremdet?

    0
  • ?

    Also eig. ist das einzige was ich brauche , das nasm den Code nicht verändert. Wenn ich die Funktion in inline Assembler von Visual Studio 2008 schreibe wird der Asm code richtig übersetzt nur nasm macht aus

    push eax

    immer

    push ax

    <.<

    0
  • ?

    SpR schrieb:

    nur nasm macht aus

    push eax

    immer

    push ax

    <.<

    entweder verwendest du den falschen dissassembler oder du bedienst ihn falsch.

    0
  • ?

    Durchausmöglich , merkwürdig ist nur , das der von Visul Atudio inline asm erstellte code läuft un der von nasm nicht^^

    0
  • R

    SpR schrieb:

    Durchausmöglich , merkwürdig ist nur , das der von Visul Atudio inline asm erstellte code läuft un der von nasm nicht^^

    NASM oder FASM? Das sind zwei verschiedene Assembler! Aber der von Dir Dir gepostete Problemcode gehört doch zum Inline-Assembler von VC++. 😕

    Ich kann Dein Problem hier immer noch nicht reproduzieren. Versuch mal folgende Kombination:

    format MS COFF
public _MyFunc
SECTION '.text' code readable executable
_MyFunc:
	push ebp
	mov ebp, esp
	mov eax, [ebp+8]
	mov ebx, 1000
	add [eax], ebx
	pop ebp
	ret

    #include <iostream>
using namespace std;
extern "C" void MyFunc(int*);

int main()
{
	int VarToChange = 1000;
	cout << "VarToChange=" << VarToChange << endl;

	MyFunc (&VarToChange);
	cout << "VarToChange=" << VarToChange << endl;

	_asm
	{
		lea eax, VarToChange
		push eax
		call MyFunc
		add esp, 4
	}
	cout << "VarToChange=" << VarToChange << endl;

	return 0;
}

    Diese Kombination sollte klappen. Die FASM-Funktion addiert immer 1000 zur übergebenen Variable. Beachte, dass man bei der C-Calling-Convention den Stack selbst aufräumen muss (Zeile 18 der C++-Datei).

    viele grüße
    ralph

    0
  • ?

    SpR schrieb:

    push ebp
    mov bp,sp
    mov ax,word ptr [di+8]
    mov bx,64h
    add byte ptr [eax],al
    add word ptr [bx+si],bx
    pop bp
    ret

    Sollte möglichst was korrumpieren.
    Um aber dir alles sagen zu können müsstest du schon mal
    dein komplettes Disassembly posten. 😉
    Ausserdem 16Bit mit 32Bit kram zu mischen ist auch nicht so toll.

    Warum benutzt du nicht MASM32 ?

    Auch unter Win7 kann man Software Interrupts benutzen,
    sofern du dich im Kernelmodus "befindest".

    PS: Du kannst auch direkt IASM verwenden:

    __declspec(naked) BLA CALLINGBLA name(BLUB)
{
    __asm {

        ret
    }
}
    0
  • ?

    Warum benutzt du nicht die HL-Syntax von MASM? Ist doch viel bequemer.
    Merke: ESI, EDI, EBX müssen vor Ende der Subfunktion wieder auf die Werte vor dem Aufruf zurückgestellt werden (Push/Pop)
    MASM-Beispiel: \MASM32\datetime\CopyDateTime.asm

    .486                      ; create 32 bit code
    .model flat      ; 32 bit memory model
    option casemap :none      ; case sensitive
    MyFunc PROTO C :DWORD

myval equ 1234

MyFunc proc C uses ebx edi esi myvar:DWORD
	mov eax,myvar
	mov [dword ptr eax],myval

;oder:
;	add dword ptr [eax],myval
;oder:
;	mov ebx,myval
;	sub dword ptr [eax],ebx
	ret
MyFunc endp

end
    0
  • ?

    Tut mir leid wegen dem pop ebp und pop ebp habe ich leider vergessen ich benutze nasm als Assembler. Das Problem hat sich schon geklärt. Vielen Dank für die Antworten konnte in diesem Fall viel lernen.

    0
Anmelden zum Antworten