FASM UDF (X86 u X64)

  • Klar, kein Problem: (so sinnlos ^^)

    [autoit]

    #include "FASM.au3"

    [/autoit][autoit][/autoit][autoit]

    Global $vRet
    Global $sASM = _
    '# use64' & _
    '# movq mm0, mm1' & _
    '# ret'

    [/autoit][autoit][/autoit][autoit]

    $FASM_RUN[0][0] = 'INT64'

    [/autoit][autoit][/autoit][autoit]

    $dCode = FASM_Assemble($sASM)
    If Not FASM_Error() Then $vRet = FASM_Run($dCode)
    ConsoleWrite($vRet & @CRLF)

    [/autoit]

    Einmal editiert, zuletzt von Yjuq (27. November 2014 um 21:55)

  • 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
    autoit.de/wcf/attachment/24955/

    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 8o (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...

    ciao
    Andy


    "Schlechtes Benehmen halten die Leute doch nur deswegen für eine Art Vorrecht, weil keiner ihnen aufs Maul haut." Klaus Kinski
    "Hint: Write comments after each line. So you can (better) see what your program does and what it not does. And we can see what you're thinking what your program does and we can point to the missunderstandings." A-Jay

    Wie man Fragen richtig stellt... Tutorial: Wie man Script-Fehler findet und beseitigt...X-Y-Problem

    3 Mal editiert, zuletzt von Andy (27. November 2014 um 23:58)

  • 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 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])
    ; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

    [/autoit] [autoit][/autoit] [autoit]

    #include-once

    [/autoit] [autoit][/autoit] [autoit]

    Global $FASM_DLL = 'FASM.dll'
    Global $FASM_RUN[1][2] = [['dword']]

    [/autoit] [autoit][/autoit] [autoit]

    Global Const $tagFASM_STATE = 'dword condition; dword output_length; dword error_code; dword output_data; dword error_line'
    Global Const $tagLINE_HEADER = 'dword file_path; dword line_number; dword file_offset; dword macro_calling_line; dword macro_line'

    [/autoit] [autoit][/autoit] [autoit]

    Global Const $FASM_OK = 0
    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 = -8

    [/autoit] [autoit][/autoit] [autoit]

    Global Const $FASMERR_FILE_NOT_FOUND = -101
    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]

    ; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

    [/autoit] [autoit][/autoit] [autoit]

    Func FASM_Assemble($sAsm)
    Local $tMemory = DllStructCreate('byte var[8388608]')
    Local $tState = DllStructCreate($tagFASM_STATE, DllStructGetPtr($tMemory))
    Local $iAdd, $tBuffer, $tError, $tCode

    [/autoit] [autoit][/autoit] [autoit]

    $sAsm = StringReplace($sAsm, '#', @CRLF)
    $iAdd = @extended
    $tBuffer = DllStructCreate('byte var[' & StringLen($sAsm) + $iAdd & ']')
    DllStructSetData($tBuffer, 'var', $sAsm)

    [/autoit] [autoit][/autoit] [autoit]

    DllCall($FASM_DLL, 'dword', 'fasm_Assemble', 'ptr', DllStructGetPtr($tBuffer), 'ptr', DllStructGetPtr($tMemory), 'dword', DllStructGetSize($tMemory), 'dword', 100, 'dword', 0)
    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

    [/autoit] [autoit][/autoit] [autoit]

    $tCode = DllStructCreate('byte var[' & DllStructGetData($tState, 'output_length') & ']', DllStructGetData($tState, 'error_code'))
    Return SetError($FASM_OK, 2, DllStructGetData($tCode, 'var'))
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func FASM_Error($iError = @error, $iExtended = @extended)
    Local $sError

    [/autoit] [autoit][/autoit] [autoit]

    Switch $iExtended
    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'
    EndSwitch

    [/autoit] [autoit][/autoit] [autoit]

    If $iError <> $FASM_OK Then ConsoleWrite('! FASM Error: ' & $sError & @CRLF)
    Return SetError($iError, $iExtended, $iError)
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    Func FASM_Run($dCode, $avParam = $FASM_RUN)
    Local $tCode = DllStructCreate('byte var[' & BinaryLen($dCode) +6 & ']')
    Local $sScript = 'DllCallAddress("' & $avParam[0][0] & '",DllStructGetPtr($tCode)'
    Local $i, $n, $avRet

    [/autoit] [autoit][/autoit] [autoit]

    DllStructSetData($tCode, 'var', $dCode)
    For $i = 1 To UBound($avParam, 1) -1
    $sScript &= ',"' & $avParam[$i][0] & '","' & $avParam[$i][1] & '"'
    Next
    $sScript &= ')'

    [/autoit] [autoit][/autoit] [autoit]

    $avRet = Execute($sScript)
    If Not @error Then Return $avRet[0]
    Return SetError(@error, 3, 0)
    EndFunc

    [/autoit] [autoit][/autoit] [autoit]

    ; ++++++++++ +++++++++ ++++++++ +++++++ ++++++ +++++ ++++ +++ ++ +

    [/autoit]
  • 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 ....

    3 Mal editiert, zuletzt von WhiteLion (28. November 2014 um 18:42)

  • 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 8o
    Ein Flag zu setzen, und *schwupps* wird 64-Bit-Code erstellt, DAS hat was 8)

  • 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 :D
    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...
    autoit.de/wcf/attachment/24957/ uups, sorry, Make-Grafik hatte das ja schon gepostet...

    //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...

    ciao
    Andy


    "Schlechtes Benehmen halten die Leute doch nur deswegen für eine Art Vorrecht, weil keiner ihnen aufs Maul haut." Klaus Kinski
    "Hint: Write comments after each line. So you can (better) see what your program does and what it not does. And we can see what you're thinking what your program does and we can point to the missunderstandings." A-Jay

    Wie man Fragen richtig stellt... Tutorial: Wie man Script-Fehler findet und beseitigt...X-Y-Problem

    4 Mal editiert, zuletzt von Andy (29. November 2014 um 12:18)