vielen dank, aber das entscheide hast du mir leider nicht verraten... funktioniert sie auch mit 64bit kompilierung ? / kann sie 64 bit code erzeugen ?
FASM UDF (X86 u X64)
-
-
Klar, kein Problem: (so sinnlos ^^)
[autoit]#include "FASM.au3"
[/autoit][autoit][/autoit][autoit]Global $vRet
[/autoit][autoit][/autoit][autoit]
Global $sASM = _
'# use64' & _
'# movq mm0, mm1' & _
'# ret'$FASM_RUN[0][0] = 'INT64'
[/autoit][autoit][/autoit][autoit]$dCode = FASM_Assemble($sASM)
[/autoit]
If Not FASM_Error() Then $vRet = FASM_Run($dCode)
ConsoleWrite($vRet & @CRLF) -
Hi,
schau mal nach AssembleIt bzw. AssembleIt2
AssembleIt2 hat die Fasm.dll integriert und bietet auch noch weitere "goodies", allerdings noch nicht den integrierten Debugger aus AssembleIt.Beispiele für 64-Bit-Code gibts hier,
Die FASM.dll kann sehr wohl 64Bit-Code assemblieren, kann allerdings selbst nicht im 64-Bit-Modus geladen werden (trancexx´s Methode die dll aus dem Script in den Speicher zu laden funzt nur bei 32Bit)
Da du aber sowieso nur den Bytecode benötigst, macht das nichts...Hier noch kleine Testdateien
Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist. Wer sich wundert, warum es ein AssembleIt2-32 gibt, das ist exakt dieselbe Version, allerdings ist dort das Laden der FASM.dll "außerhalb" der Funktion untergebracht, das spart je Aufruf bei meinem Rechner 100ms.
Da somit AssembleIt2() nur 2-3ms Overhead für einen Aufruf hat(in diesen 2-3ms wird assembliert und der code ausgeführt!!!! ), lohnt sich das assemblieren und der folgende DllCallAddress() nur noch in Ausnahmefällen
(oder wenn man seinen Code schlank halten muss...)
Den Unterschied sieht man deutlich im Beispiel mit der Farbpalette, dort bei der #include <assembleit2-32.au3> einfach mal das -32 wegmachen... -
danke an euch beide für die mühe....
@Make-Grafik
deine version läuft bei mir nicht wegen dieser "neumodischen objekte" ala "$tCode.var" die mein AutoIt 3.3.8.1 nicht mag (leider kann ich nicht updaten, da ich dann bei meinem projekt viele anpassungen machen muss
- (hatte es versucht und bekomme dann abstürtze ohne fehlermeldungen in meinem großen projekt die ich nicht nachvollziehen kann und aufgrund von zeitmangel hab ich dann wieder die alte version eingespielt.)@Andy
das doppelte kompilieren kommt für mich irgendwie auch auch nicht in frage, denn ich hatte mir das so vorgestellt, dass ich in meiner 64bit kompilieren anwendung bytecode erzeugen lasse, den ich per klick als 32 oder halt 64 bit bitcode ausgeben lasse. (den code an sich und nicht starten oder sowas) -
Diese "neumodischen" Objekte kannst du einfach durch DllStructGetData() ersetzen, dann läuft die UDF auch auf älteren Versionen. Ich hab's dir freundlicherweise mal gemacht:
Spoiler anzeigen
[autoit]; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]
; AutoIt Version: 3.3.12.0
; FASM Version: 1.71
; Author: Make-Grafik
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
; FASM_Assemble ($sAsm)
; FASM_Error ([$iError = @error[, $iExtended = @extended]])
; FASM_Run ($dCode[, $avParam = $FASM_RUN])
; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +#include-once
[/autoit] [autoit][/autoit] [autoit]Global $FASM_DLL = 'FASM.dll'
[/autoit] [autoit][/autoit] [autoit]
Global $FASM_RUN[1][2] = [['dword']]Global Const $tagFASM_STATE = 'dword condition; dword output_length; dword error_code; dword output_data; dword error_line'
[/autoit] [autoit][/autoit] [autoit]
Global Const $tagLINE_HEADER = 'dword file_path; dword line_number; dword file_offset; dword macro_calling_line; dword macro_line'Global Const $FASM_OK = 0
[/autoit] [autoit][/autoit] [autoit]
Global Const $FASM_WORKING = 1
Global Const $FASM_ERROR = 2
Global Const $FASM_INVALID_PARAMETER = -1
Global Const $FASM_OUT_OF_MEMORY = -2
Global Const $FASM_STACK_OVERFLOW = -3
Global Const $FASM_SOURCE_NOT_FOUND = -4
Global Const $FASM_UNEXPECTED_END_OF_SOURCE = -5
Global Const $FASM_CANNOT_GENERATE_CODE = -6
Global Const $FASM_FORMAT_LIMITATIONS_EXCEDDED = -7
Global Const $FASM_WRITE_FAILED = -8Global Const $FASMERR_FILE_NOT_FOUND = -101
[/autoit] [autoit][/autoit] [autoit]
Global Const $FASMERR_ERROR_READING_FILE = -102
Global Const $FASMERR_INVALID_FILE_FORMAT = -103
Global Const $FASMERR_INVALID_MACRO_ARGUMENTS = -104
Global Const $FASMERR_INCOMPLETE_MACRO = -105
Global Const $FASMERR_UNEXPECTED_CHARACTERS = -106
Global Const $FASMERR_INVALID_ARGUMENT = -107
Global Const $FASMERR_ILLEGAL_INSTRUCTION = -108
Global Const $FASMERR_INVALID_OPERAND = -109
Global Const $FASMERR_INVALID_OPERAND_SIZE = -110
Global Const $FASMERR_OPERAND_SIZE_NOT_SPECIFIED = -111
Global Const $FASMERR_OPERAND_SIZES_DO_NOT_MATCH = -112
Global Const $FASMERR_INVALID_ADDRESS_SIZE = -113
Global Const $FASMERR_ADDRESS_SIZES_DO_NOT_AGREE = -114
Global Const $FASMERR_DISALLOWED_COMBINATION_OF_REGISTERS = -115
Global Const $FASMERR_LONG_IMMEDIATE_NOT_ENCODABLE = -116
Global Const $FASMERR_RELATIVE_JUMP_OUT_OF_RANGE = -117
Global Const $FASMERR_INVALID_EXPRESSION = -118
Global Const $FASMERR_INVALID_ADDRESS = -119
Global Const $FASMERR_INVALID_VALUE = -120
Global Const $FASMERR_VALUE_OUT_OF_RANGE = -121
Global Const $FASMERR_UNDEFINED_SYMBOL = -122
Global Const $FASMERR_INVALID_USE_OF_SYMBOL = -123
Global Const $FASMERR_NAME_TOO_LONG = -124
Global Const $FASMERR_INVALID_NAME = -125
Global Const $FASMERR_RESERVED_WORD_USED_AS_SYMBOL = -126
Global Const $FASMERR_SYMBOL_ALREADY_DEFINED = -127
Global Const $FASMERR_MISSING_END_QUOTE = -128
Global Const $FASMERR_MISSING_END_DIRECTIVE = -129
Global Const $FASMERR_UNEXPECTED_INSTRUCTION = -130
Global Const $FASMERR_EXTRA_CHARACTERS_ON_LINE = -131
Global Const $FASMERR_SECTION_NOT_ALIGNED_ENOUGH = -132
Global Const $FASMERR_SETTING_ALREADY_SPECIFIED = -133
Global Const $FASMERR_DATA_ALREADY_DEFINED = -134
Global Const $FASMERR_TOO_MANY_REPEATS = -135
Global Const $FASMERR_SYMBOL_OUT_OF_SCOPE = -136
Global Const $FASMERR_USER_ERROR = -140
Global Const $FASMERR_ASSERTION_FAILED = -141; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] [autoit][/autoit] [autoit]Func FASM_Assemble($sAsm)
[/autoit] [autoit][/autoit] [autoit]
Local $tMemory = DllStructCreate('byte var[8388608]')
Local $tState = DllStructCreate($tagFASM_STATE, DllStructGetPtr($tMemory))
Local $iAdd, $tBuffer, $tError, $tCode$sAsm = StringReplace($sAsm, '#', @CRLF)
[/autoit] [autoit][/autoit] [autoit]
$iAdd = @extended
$tBuffer = DllStructCreate('byte var[' & StringLen($sAsm) + $iAdd & ']')
DllStructSetData($tBuffer, 'var', $sAsm)DllCall($FASM_DLL, 'dword', 'fasm_Assemble', 'ptr', DllStructGetPtr($tBuffer), 'ptr', DllStructGetPtr($tMemory), 'dword', DllStructGetSize($tMemory), 'dword', 100, 'dword', 0)
[/autoit] [autoit][/autoit] [autoit]
If @error Then Return SetError(@error, 1, 0)
If DllStructGetData($tBuffer, 'condition') Then
$tError = DllStructCreate($tagLINE_HEADER, DllStructGetData($tState, 'error_code'))
Return SetError(DllStructGetData($tState, 'output_length'), 2, DllStructGetData($tError, 'line_number'))
EndIf$tCode = DllStructCreate('byte var[' & DllStructGetData($tState, 'output_length') & ']', DllStructGetData($tState, 'error_code'))
[/autoit] [autoit][/autoit] [autoit]
Return SetError($FASM_OK, 2, DllStructGetData($tCode, 'var'))
EndFuncFunc FASM_Error($iError = @error, $iExtended = @extended)
[/autoit] [autoit][/autoit] [autoit]
Local $sErrorSwitch $iExtended
[/autoit] [autoit][/autoit] [autoit]
Case 1
Switch $iError
Case 1
$sError = 'unable to use the DLL file'
Case 2
$sError = 'unknown "return type"'
Case 3
$sError = '"function" not found in the DLL file'
Case 4
$sError = 'bad number of parameters'
Case 5
$sError = 'bad parameter'
EndSwitch
Case 2
Switch $iError
Case $FASM_OK
$sError = 'OK'
Case $FASM_WORKING
$sError = 'WORKING'
Case $FASM_ERROR
$sError = 'ERROR'
Case $FASM_INVALID_PARAMETER
$sError = 'INVALID PARAMETER'
Case $FASM_OUT_OF_MEMORY
$sError = 'OUT OF MEMORY'
Case $FASM_STACK_OVERFLOW
$sError = 'STACK OVERFLOW'
Case $FASM_SOURCE_NOT_FOUND
$sError = 'NOT FOUND'
Case $FASM_UNEXPECTED_END_OF_SOURCE
$sError = 'END OF SOURCE'
Case $FASM_CANNOT_GENERATE_CODE
$sError = 'GENERATE CODE'
Case $FASM_FORMAT_LIMITATIONS_EXCEDDED
$sError = 'FORMAT LIMITATIONS EXCEDDED'
Case $FASM_WRITE_FAILED
$sError = 'WRITE FAILED'
Case $FASMERR_FILE_NOT_FOUND
$sError = 'FILE NOT FOUND'
Case $FASMERR_ERROR_READING_FILE
$sError = 'ERROR READING FILE'
Case $FASMERR_INVALID_FILE_FORMAT
$sError = 'INVALID FILE FORMAT'
Case $FASMERR_INVALID_MACRO_ARGUMENTS
$sError = 'INVALID MACRO ARGUMENTS'
Case $FASMERR_INCOMPLETE_MACRO
$sError = 'INCOMPLETE MACRO'
Case $FASMERR_UNEXPECTED_CHARACTERS
$sError = 'UNEXPECTED CHARACTERS'
Case $FASMERR_INVALID_ARGUMENT
$sError = 'INVALID ARGUMENT'
Case $FASMERR_ILLEGAL_INSTRUCTION
$sError = 'ILLEGAL INSTRUCTION'
Case $FASMERR_INVALID_OPERAND
$sError = 'INVALID OPERAND'
Case $FASMERR_INVALID_OPERAND_SIZE
$sError = 'INVALID OPERAND SIZE'
Case $FASMERR_OPERAND_SIZE_NOT_SPECIFIED
$sError = 'OPERAND SIZE NOT SPECIFIED'
Case $FASMERR_OPERAND_SIZES_DO_NOT_MATCH
$sError = 'OPERAND SIZES DO NOT MATCH'
Case $FASMERR_INVALID_ADDRESS_SIZE
$sError = 'INVALID ADDRESS SIZE'
Case $FASMERR_ADDRESS_SIZES_DO_NOT_AGREE
$sError = 'ADDRESS SIZES DO NOT AGREE'
Case $FASMERR_DISALLOWED_COMBINATION_OF_REGISTERS
$sError = 'DISALLOWED COMBINATION OF REGISTERS'
Case $FASMERR_LONG_IMMEDIATE_NOT_ENCODABLE
$sError = 'LONG IMMEDIATE NOT ENCODABLE'
Case $FASMERR_RELATIVE_JUMP_OUT_OF_RANGE
$sError = 'RELATIVE JUMP OUT OF RANGE'
Case $FASMERR_INVALID_EXPRESSION
$sError = 'INVALID EXPRESSION'
Case $FASMERR_INVALID_ADDRESS
$sError = 'INVALID ADDRESS'
Case $FASMERR_INVALID_VALUE
$sError = 'INVALID VALUE'
Case $FASMERR_VALUE_OUT_OF_RANGE
$sError = 'VALUE OUT OF RANGE'
Case $FASMERR_UNDEFINED_SYMBOL
$sError = 'UNDEFINED SYMBOL'
Case $FASMERR_INVALID_USE_OF_SYMBOL
$sError = 'INVALID USE OF SYMBOL'
Case $FASMERR_NAME_TOO_LONG
$sError = 'NAME TOO LONG'
Case $FASMERR_INVALID_NAME
$sError = 'INVALID NAME'
Case $FASMERR_RESERVED_WORD_USED_AS_SYMBOL
$sError = 'RESERVED WORD USED AS SYMBOL'
Case $FASMERR_SYMBOL_ALREADY_DEFINED
$sError = 'SYMBOL ALREADY DEFINED'
Case $FASMERR_MISSING_END_QUOTE
$sError = 'MISSING END QUOTE'
Case $FASMERR_MISSING_END_DIRECTIVE
$sError = 'END DIRECTIVE'
Case $FASMERR_UNEXPECTED_INSTRUCTION
$sError = 'UNEXPECTED INSTRUCTION'
Case $FASMERR_EXTRA_CHARACTERS_ON_LINE
$sError = 'EXTRA CHARACTERS ON LINE'
Case $FASMERR_SECTION_NOT_ALIGNED_ENOUGH
$sError = 'SECTION NOT ALIGNED ENOUGHT'
Case $FASMERR_SETTING_ALREADY_SPECIFIED
$sError = 'SETTING ALREADY SPECIFIED'
Case $FASMERR_DATA_ALREADY_DEFINED
$sError = 'DATA ALREADY DEFINED'
Case $FASMERR_TOO_MANY_REPEATS
$sError = 'TOO MANY REPEATS'
Case $FASMERR_SYMBOL_OUT_OF_SCOPE
$sError = 'SYMBOL OUT OF SCOPE'
Case $FASMERR_USER_ERROR
$sError = 'USER ERROR'
Case $FASMERR_ASSERTION_FAILED
$sError = 'ASSERTION FAILED'
EndSwitch
Case 3
$sError = 'RUN'
EndSwitchIf $iError <> $FASM_OK Then ConsoleWrite('! FASM Error: ' & $sError & @CRLF)
[/autoit] [autoit][/autoit] [autoit]
Return SetError($iError, $iExtended, $iError)
EndFuncFunc FASM_Run($dCode, $avParam = $FASM_RUN)
[/autoit] [autoit][/autoit] [autoit]
Local $tCode = DllStructCreate('byte var[' & BinaryLen($dCode) +6 & ']')
Local $sScript = 'DllCallAddress("' & $avParam[0][0] & '",DllStructGetPtr($tCode)'
Local $i, $n, $avRetDllStructSetData($tCode, 'var', $dCode)
[/autoit] [autoit][/autoit] [autoit]
For $i = 1 To UBound($avParam, 1) -1
$sScript &= ',"' & $avParam[$i][0] & '","' & $avParam[$i][1] & '"'
Next
$sScript &= ')'$avRet = Execute($sScript)
[/autoit] [autoit][/autoit] [autoit]
If Not @error Then Return $avRet[0]
Return SetError(@error, 3, 0)
EndFunc; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +
[/autoit] -
klasse ... das geht.... danke für die mühe
allerdings geht es nur bei der kompilierung mit 32 bit
geht:
#AutoIt3Wrapper_UseX64=n
geht nicht:
#AutoIt3Wrapper_UseX64=y -
Das kannst du im Grunde gleich vergessen...
Wenn ich mich nicht irre nutzt sowohl Andy und eukalyptus die FASM.dll
Diese wurde nur als 32 Bit Dll kompiliert.
Sofern du den ganzen Sourcecode der DLL nicht umschreiben möchtest (auf x64 anpassen) kannst du die DLL im 64 Bit Mode nicht nutzen.
Aber evtl. kannst du die FASM.exe nutzen und diese deinen Code kompilieren lassen.Ich glaub da kann dir Andy bestimmt besser helfen als ich.
-
dass ich in meiner 64bit kompilieren anwendung bytecode erzeugen lasse, den ich per klick als 32 oder halt 64 bit bitcode ausgeben lasse. (den code an sich und nicht starten oder sowas)
Also nochmal deutlich:
Die Fasm.dll assembliert sowohl 64-Bit- als auch 32-bit-Code!
Die Frage stellt sich, was eine 64-Bit Anwendung macht, die lediglich assemblieren soll?! Assembliere im 32-Bitmodus und alles ist paletti!das doppelte kompilieren kommt für mich irgendwie auch auch nicht in frage,
Ich vermute stark, du verstehst garnicht was überhaupt vor sich geht...
Grundsätzlich wird nichts kompiliert, sondern assembliert.
Und "doppelt" wird auch nichts assembliert, sondern nur ein Mal.
Im "1. Durchgang" wird der 64-Bit-Code assembliert. Das kannst du, jedenfalls mit der von mir vorgestellten Lösung mit der im Script integrierten Fasm.dll nur im 32-Bit-Modus.
Das braucht man genau ein einziges Mal, um den Assemblercode zu assemblieren. Ich hab ja keine Ahnung, ob du jedes Mal, bevor du ein Programm startest, dieses Programm kompilierst, ich mach das nur ein einziges Mal, dann habe ich meine Exe...Der "2. Durchgang" schaltet in den 64-Bit-Modus, damit der 64-Bit-Code überhaupt läuft! Wenn du lediglich assemblieren willst, brauchst du das natürlich nicht!
Da im FASM-Paket sowohl FASM.EXE (der Assembler), als auch FASMW.exe (mit integriertem Editor, den benutze ich) enthalten ist, sei die Frage erlaubt, wieso du nicht damit deine ASM-Codes assemblierst? In AutoIt ist das ein Einzeiler!
Vielleicht solltest du uns in einigen Sätzen einfach mal erklären, was du genau mit deinem Code machen möchtest bzw. wieso du diese AutoItlösung fürs assemblieren brauchst. Das erspart allen Beteiligten das rumgeeiere...
-
Ja sorry, ich meinte ja auch nicht, dass es doppelt kompiliert wird ... war etwas unglücklich von ausgedrückt.
Was ich genau möchte ist eigentlich gar nicht so kompliziert (dachte ich):
Ich möchte nur bytecode und zwar aus assembler code welchen ich in einem edit-feld schreibe. (so wie das halt ein assembler macht
jmp 0040FA100 = EB ...... )
die Autoit-Anwendung aus der ich diesen code generiere muss zwingend 64-kompiliert werden. (also #AutoIt3Wrapper_UseX64=y)
und der bytecode soll optional 32 oder auch als 64 bit variante assembliert herauskommen. (dazu benuzte ich eine checkbox [x] genetiere 32Bit Bytecode (sonst 64))
schön wäre es, wenn es ohne irgendwelche dll oder exe drops auf die platte funktioniert, ist aber kein muss.Mein Problem hat Make-Grafik ja schon gut erkannt: sobald man sein programm 64-kompiliert funktioniert das ganze nicht mehr, weil wohl dann aus einer 64 bit anwendung eine
32 bit dll gecalled wird .... -
In dem Fall wirst du auf die FASM.exe zurückgreifen müssen (sofern du selber nicht die DLL anpassen willst).
Wenn du ganz ohne EXE und DLL auskommen willst, darfst du dir dein eigenen Assemblierer schreiben.
Aber stell dir mal die Frage welchen Sinn es hat Code in einem eigenen Programm zu assemblieren.
Normalerweise kompiliert man den Code vorher und nutzt diesen dann. Sei es als Anwendung, DLL oder Binärcode.. -
und der bytecode soll optional 32 oder auch als 64 bit variante assembliert herauskommen. (dazu benuzte ich eine checkbox [x] genetiere 32Bit Bytecode (sonst 64))
Oha, wenn du so weit bist, sag Bescheid!
Einfach per Checkbox aus 32-Bit-Code einen 64-Bit-Code zu machen oder umgekehrt, DAS interessiert mich jetzt!
Dir ist mit Sicherheit garnicht klar, was du da schreibst...
Ein ASSEMBLER übersetzt lediglich die in Assemblersprache geschriebenen Mnemonics eins zu eins in Opcodes. Da wird nichts kompiliert oder "übersetzt". Der Programmierer legt mit seinem Code fest, ob 64-Bit-Code oder 32-Bit-Code oder 16-Bit-Code oder 8-Bit-Code erstellt wird! Von den Macros ganz zu schweigen....
64-Bit und 32-Bit sind zwei völlig verschiedene Paar Schuhe!
Das geht bei den calling conventions los und hört beim verwendbaren Adressraum auf. Dazwischen befinden sich sämtliche Interna von x86-Prozessoren, Register, Cache usw.Aber ich lasse mich ja gerne überraschen
Ein Flag zu setzen, und *schwupps* wird 64-Bit-Code erstellt, DAS hat was
-
Im Grunde ist das möglich, dann müssten die Mnemonics vorab komplett geparst werden.
Jedoch müssen dann auch bestimmte Regeln beachtet werden dass z.B. push in Kombination mit einem 32 Bit Register nicht mehr funktioniert. (und so ein Gedönse ^^)
Generell machbar, aber aufwendig...Ich bin gespannt was bei herum kommt!
@WhiteLion
Wenn du dann schon was brauchbares hast zögere nicht mit uns zu teilen! Das wäre wirklich fantastisch. -
Ich muss Euch leider enttäuschen.... ich habe leider nichts, außer meine Fantasie
Auch ist mir ein Großteil der Problem bekannt- Nein halt, ich will es mal so ausdrücken:
Mir ist folgendes auch bekannt:
Ein ASSEMBLER übersetzt lediglich die in Assemblersprache geschriebenen Mnemonics eins zu eins in Opcodes.
Nur war mir nicht bekannt dass ich aus einer 64-bit Anwendung keine module mit 32 bit ansprechen kann.
Ich rufe ja nur funktionen der DLL auf denen ich was übergebe. (zb "push ebx"... oder so)
heraus bekomme ich dann eben den opcode für 32 bit, oder eben den für 64 bit (das funktioniert ja schon)
dann herhalte ich einen rückgabewert oder pointer auf eine struct ...etc
warum kann ich jetzt nicht angeben, dass diese rückgabe eine 32 oder 64 ist um dann das richtige (stack/calling convention)
zu veranlassen um die rückgabe richtig zu interpretieren.
gibt es dafür keine windows API´s oder OS - seitige lösung ? - das 64 bit betriebsystem kommt ja auch mit beidem klar ...
sich denke ich wohl viel zu naiv, trotzdem würde ich mich freuen etwas dazu zu lernen und die probleme zu verstehen.ich bin /war ich wohl von der AutoIt Community so verwöhnt (es gibt mittlerweile so
viele spielereien mit ASM in den AutoIt - Foren), dass ich dachte es würde dafür auch bereits was geben.
Das einfachste wäre dann wohl einfach die Make-Grafik - Variante zu benutzen und eine 32-bit anwendung zu droppen
und dann mir den krams zurückgeben zu lassen in meine 64 -bit anwendung zu importieren. -
warum kann ich jetzt nicht angeben, dass diese rückgabe eine 32 oder 64 ist um dann das richtige (stack/calling convention)
zu veranlassen um die rückgabe richtig zu interpretieren.Ich bin jetzt mal vorsichtig...
Hast du jemals in Assembler programmiert?
Ich meine jetzt nicht irgendwelche abgetipperten 3-Zeiler, sondern eigenständige Anwendungen, Treiber, Dll´s, oder auch nur irgendwelche kleinen Tools, oder auch nur diese neumodischen "Injections" (früher hat man einfach nur TSR´s "umgebogen" ). Com- oder Exe-Files erstellt?Generell machbar, aber aufwendig...
Was imho die Frage beantwortet, wieso es die FASM-DLL nicht als "reine" 64-Bit-Anwendung gibt. Es besteht absolut kein Grund dafür! Ich kann doch ohne weiteres die 32-Bit-FASM.exe aus einem 64-Bit-Programm aufrufen!
Die Compilerbauer sitzen in den Hardwareabteilungen der Prozessorhersteller! Die neuen Prozessoren haben unglaublich aufwendige Möglichkeiten bei der Umsortierung und internen Ablauforganisation. Ein Assemblerprogrammierer müsste, um auch nur annähernd an diesen Level zu kommen, ständig für jeden Prozessor die optimalen Abläufe im Hinterkopf haben und das auch parallel für sämtliche verfügbaren Prozessoren in sein Programm implementieren um auch nur annähernd an die Leistungsfähigkeit der Compiler heranzukommen. Völlig illusorisch!
Assembler ist/wird dann interessant, wenn die Compiler nicht an die erwarteten maximalen theoretischen Möglichkeiten der Prozessoren herankommen. Dann schlägt die Stunde der "Hardcore"-Assemblerprogrammierer. Davon dürfte es aber nicht mehr als einige Handvoll weltweit geben. Und die sitzen wiederum wo?
...in den Hardwareabteilungen der Prozessorhersteller!
@WhiteLion
Anbei meine erste Version zur Benutzung der FASM.dll, input x86-Mnemonics, output Maschinencode. Integriert ist Syntaxcheck und die Fehlermeldungen.
Ich denke, so etwas ähnliches hilft dir weiter...uups, sorry, Make-Grafik hatte das ja schon gepostet...Der Inhalt kann nicht angezeigt werden, da er nicht mehr verfügbar ist. //EDIT
übrigens funktioniert eukalyptus´ UDF sowohl für 32-Bit- als auch für 64-Bit-Code einwandfrei, ich frage mich, was daran zu bemäkeln ist...
