[ASM] Brainfuck-compiler bauen

Kaeru Gaman · Beitrag von **Kaeru Gaman** » 06.02.2007 22:05

> Laut kaero soll ich mit call die api's aufrufen können - hä? adresse?

lol....

Kaeru Gaman hat geschrieben:
Biedermeier hat geschrieben:Register mit parametern füllen und dann "Call <befehlname>" oder so ?
yup

...oder so....

PS:
natürlich muss FASM gesagt bekommen, was du callen willst.
ich hab keinen plan, wie das eingebunden ist, ob die API-Calls irgendwie vordefiniert sind oder was...

wie wärs, wenn du dir erstmal die anleitung vom FASM vornimmst
und durchliest, bevor du drauf los codest und dich wunderst?

Leonhard · Beitrag von **Leonhard** » 06.02.2007 22:15

Da hier welche Probleme mit Proceduren-Aufrufen und so weiter in Assembler haben, hab ich hier den Code von PureBasic zu Assembelr (ohne Debugger) übersetzt:
In PureBasic:

Code: Alles auswählen

Procedure.s MyProcedure(StringParameter.s, LongParameter.l)
  Protected sLocalString.s
  
  sLocalString = Mid(StringParameter, 1, LongParameter)
  
  ProcedureReturn sLocalString
EndProcedure

Define Out$ = MyProcedure("Hallo, PureBasic!", 5)

MessageRequester("Title", Out$)

End 1

In Assembler (mit nem Tool von mir mit den Orginal-Zeilen als Kommentare angegeben werden):

Code: Alles auswählen

; 
; PureBasic v4.02 (Windows - x86) generated code
; 
; © 2006 Fantaisie Software
; 
; The header must remain intact for Re-Assembly
; 
; String
; StringExtension
; Requester
; FileSystem
; Date
; Object
; SimpleList
; :System
; KERNEL32
; 
format MS COFF
; 
extrn _ExitProcess@4
extrn _GetModuleHandleA@4
extrn _HeapCreate@12
extrn _HeapDestroy@4
; 
extrn _PB_FreeSimpleLists@0
extrn _PB_InitRequester@0
extrn _PB_InitSimpleList@0
extrn _PB_MessageRequester@8
extrn _PB_Mid@16
extrn _SYS_CopyString@0
extrn _memset
extrn SYS_AllocateString
extrn SYS_FastAllocateString
extrn _SYS_FreeString@4
extrn _PB_StringBase
extrn  PB_StringBase
extrn _SYS_InitString@0
; 
extrn _PB_StringBasePosition
public _PB_Instance
public _PB_ExecutableType
public _PB_MemoryBase
public PB_Instance
public PB_MemoryBase
public _PB_EndFunctions
public _PB_DEBUGGER_LineNumber
public _PB_DEBUGGER_IncludedFiles

macro pb_public symbol
{
  public  _#symbol
  public symbol
_#symbol:
symbol:
}

macro    align value { rb (value-1) - ($-_PB_DataSection + value-1) mod value }
macro bssalign value { rb (value-1) - ($-_PB_BSSSection  + value-1) mod value }
public PureBasicStart
; 
section '.code' code readable executable
; 
; 
PureBasicStart:
; 
  PUSH   dword I_BSSEnd-I_BSSStart
  PUSH   dword 0
  PUSH   dword I_BSSStart
  CALL  _memset
  ADD    esp,12
  PUSH   dword 0
  CALL  _GetModuleHandleA@4
  MOV    [_PB_Instance],eax
  PUSH   dword 0
  PUSH   dword 4096
  PUSH   dword 0
  CALL  _HeapCreate@12
  MOV    [PB_MemoryBase],eax
  CALL  _SYS_InitString@0
  CALL  _PB_InitSimpleList@0
  CALL  _PB_InitRequester@0
; :
; Procedure.s MyProcedure(StringParameter.s, LongParameter.l)
macro MP0{
_Procedure0:
  PUSH   dword [esp+12]
  POP    dword [_PB_StringBasePosition]
  PS0=12
  XOR    eax,eax
  PUSH   eax
  PUSH   eax                                                                                                                                                         
  MOV    edx,dword [esp+PS0+0]
  LEA    ecx,[esp+0]
  CALL   SYS_FastAllocateString
; Protected sLocalString.s
; 
; sLocalString = Mid(StringParameter, 1, LongParameter)
  PUSH   dword [_PB_StringBasePosition]
  PUSH   dword [esp+PS0+8]
  PUSH   dword 1
  PUSH   dword [esp+12]
  CALL  _PB_Mid@16
  SUB    esp,4
  LEA    ecx,[esp+8]
  POP    edx
  CALL   SYS_AllocateString
; 
; ProcedureReturn sLocalString
  MOV    edx,dword [esp+4]
  PUSH   dword [_PB_StringBasePosition]
  CALL  _SYS_CopyString@0
  POP    eax
  ADD    eax,[PB_StringBase]
  JMP   _EndProcedure1
; EndProcedure
  MOV    eax,[_PB_StringBasePosition]
  ADD    eax,[PB_StringBase]
  MOV    byte [eax],0
_EndProcedure1:
  PUSH   dword [esp+4]
  CALL  _SYS_FreeString@4
  PUSH   dword [esp]
  CALL  _SYS_FreeString@4
  ADD    esp,8
  RET    8
}
; 
; Define Out$ = MyProcedure("Hallo, PureBasic!", 5)
  PUSH   dword [_PB_StringBasePosition]
  PUSH   dword 5
  PUSH   dword _S1
  CALL  _Procedure0
  LEA    ecx,[v_Out$]
  POP    edx
  CALL   SYS_AllocateString
; 
; MessageRequester("Title", Out$)
  PUSH   dword [v_Out$]
  PUSH   dword _S2
  CALL  _PB_MessageRequester@8
; 
; End 1
  PUSH   dword 1
  JMP   _PB_EOP
; 
_PB_EOP_NoValue:
  PUSH   dword 0
_PB_EOP:
  CALL  _PB_EndFunctions
  PUSH   dword [PB_MemoryBase]
  CALL  _HeapDestroy@4
  CALL  _ExitProcess@4
_PB_EndFunctions:
  CALL  _PB_FreeSimpleLists@0
  RET
; 
MP0
; 
section '.data' data readable writeable
; 
_PB_DataSection:
_PB_DEBUGGER_LineNumber: dd -1
_PB_DEBUGGER_IncludedFiles: dd 0
_PB_ExecutableType: dd 0
public _SYS_StaticStringStart
_SYS_StaticStringStart:
_S1: db "Hallo, PureBasic!",0
_S2: db "Title",0
pb_public PB_NullString
  db     0
public _SYS_StaticStringEnd
_SYS_StaticStringEnd:
align 4
align 4
s_s:
  dd     0
  dd     -1
align 4
; 
section '.bss' readable writeable
_PB_BSSSection:
bssalign 4
; 
I_BSSStart:
_PB_MemoryBase:
PB_MemoryBase: rd 1
_PB_Instance:
PB_Instance: rd 1
; 
bssalign 4
PB_DataPointer rd 1
v_Out$ rd 1
bssalign 4
bssalign 4
bssalign 4
bssalign 4
I_BSSEnd:
section '.data' data readable writeable
SYS_EndDataSection:

DarkSoul · Beitrag von **DarkSoul** » 06.02.2007 22:51

Aber da mischt PB ja immer noch mit und das soll ja nicht. Mein compiler soll ja unabhängig sein

.

Thorium · Beitrag von **Thorium** » 07.02.2007 05:01

Biedermeier hat geschrieben:Aber da mischt PB ja immer noch mit und das soll ja nicht. Mein compiler soll ja unabhängig sein .

So wie ich dich verstehe soll er unabhängig von PB sein aber abhängig von einem Assembler?
Wenn dem so ist dann nimm einfach FASM und schau mal in der Doku nach Invoke. FASM baut dir aus dem Invoke beim assemblieren einen richtigen call.

http://www.flatassembler.net/

Es geht zwar auch ohne Invoke, also in reinem Asm aber Invoke is der einfachste Weg.

ts-soft · Beitrag von **ts-soft** » 07.02.2007 13:10

Ich hab ja bereits einen Link zu FASM als UserLib gepostet, wurde ja ignoriert

Leonhard · Beitrag von **Leonhard** » 07.02.2007 18:22

Ich hab ja hier schon mal erwähnt:

Leonhard hat geschrieben:2. In PureBasic-Lounge gibt es jemand, der nen kleinen Compiler mit PureBasic geschrieben hat. Siehe http://www.purebasic-lounge.de/viewtopi ... t=compiler. Ich kann dir Hilfe bei der Programmierung deines Compilers geben, da ich den Code zum großteil versteht und im moment auch gerade bei der Programmierung eines Mini-Compilers bin.

Ich empfehlen den Compiler, nicht gerade, da dort ein paar Böse Fehler bei der Syntax-Überprüfung drin sind. Der Assembler-Code stimmt aber.

Bei diesem Compiler schaut das ganze so aus (der Assember- und Source-Code wurde von mir etwas verändert):
Source-Code

Code: Alles auswählen

program "Name"
	import
		int OpenConsole():"console.OBJ";
		int CloseConsole():"console.OBJ";
		int Print(string):"console.OBJ";
		int Delay(int):"misc.obj";
		string Str(int):"Conv.obj";
	endimport
	begin
		function int main()
			var
				string sInput;
			endvar
			code
				OpenConsole();
				Print("Spass: 1 Sek. Pause");
				Delay(1000);
				CloseConsole();
			endcode
		endfunction
	end
endprogram endsource

Assembler-Code

Code: Alles auswählen

format MS COFF

extrn _f_OpenConsole@0
extrn _f_CloseConsole@0
extrn _f_Print@4
extrn _f_Delay@4
extrn _f_Str@4
extrn _SYSS_Alloc@4
extrn _SYSS_Free@4
extrn _SYSS_Add@8
extrn _SYSS_Eq@8
extrn _SYSS_Assign@8
extrn _SYSS_Copy@4

section '.text' code readable executable
public _main
_main:
CALL _f_main@0
RET
     ; INSERT FUNCSTART
_f_main@0:
     ; StackFrame
     PUSH dword 0 ; local var 'sInput.4'
     MOV ecx, ebp
     MOV ebp, esp
     PUSH ebx
     PUSH ecx
     PUSH edi
     PUSH esi
     ; CALL
     CALL _f_OpenConsole@0
     ; PUSH
     PUSH dword s_S1
     ; CALL
     CALL _f_Print@4
     ; PUSH
     PUSH dword 1000
     ; CALL
     CALL _f_Delay@4
     ; CALL
     CALL _f_CloseConsole@0
     ; EndFunc
     XOR eax, eax
_f_main@0_return:
     PUSH eax
     PUSH dword [Ebp + 0]
     CALL _SYSS_Free@4
     POP eax
     POP esi
     POP edi
     POP ebp
     POP ebx
     ADD esp, 4
     RET 0
section '.data' data readable writeable
s_S0 db 'Name', 0
s_S1 db 'Spass: 1 Sek. Pause', 0

DarkSoul · Beitrag von **DarkSoul** » 07.02.2007 20:22

Der code ist doch 16-Bit, oder? Wie ändere ich ihn auf 32 Bit?

ts-soft · Beitrag von **ts-soft** » 07.02.2007 20:28

Biedermeier hat geschrieben:Der code ist doch 16-Bit, oder? Wie ändere ich ihn auf 32 Bit?

Lerne doch erstmal überhaupt die Grundlagen. Da sind nur 32-Bit Register zu sehen.
Oder wie wäre es mit Fahrrad fahren

DarkSoul · Beitrag von **DarkSoul** » 07.02.2007 20:35

nee. der code ist schon 32, aber er (FASM) versucht ihn immer als 16er zu kompilieren und stürzt natürlich ab.

Kaeru Gaman · Beitrag von **Kaeru Gaman** » 07.02.2007 20:40

I repeat:

Kaeru Gaman hat geschrieben:wie wärs, wenn du dir erstmal die anleitung vom FASM vornimmst
und durchliest, bevor du drauf los codest und dich wunderst?