Is there a way to explicitly use separate mnemonic for the operations with implicit operand, and for those using reg/rm byte? Like for the implicit operand mov(e)ax/al "some value" would have a moveax mnemonic (movax for the one whiith operand size preffix) and mov would always mean mov with operand info byte. And similarly to all operations (i don't know them all from head). Also for short/normal jumps (but i guess it can be stated with short long words before label).

i would imagine its possible with macro instructions (im not fasm expert, maybe even everything is described so?).

Please give some examples of what you want to do.

suppose, i want self modifing code, so that the operands would be modfied
so i would modify operand info byte, like increase some part of it (to use registers as continious memory). But anyhow, if thats a low level language, i just want better control over what i write (and defining it in place when i write it). You know that for mov eax, some thing there is two version for example. similarly with add etc.

so is it possible to define such instructions which would translate exactly, or if not it would be a good featuer.

I meant to give examples of how you want the instructions to look and what they would replace.

of course.

for example: if you write mov op1,op2 then it would always be translated to the opcode where the operands are placed in operand info byte (and sig if necessary), plus imm if necessary. if you write moveax op, then it would use the one by implicit eax operand opcode (i think the op here is alway imm, but whatever). so the thing is, if there is two ways to code an instruction (some have two ways, one with operand implicit in opcode) then there should be two forms, where the implicit opcode one would have the operation and implicit operand named in the opcode together such as above. obviously if there is to and from version then some word would be used to distinquesh them. I think relative jumps, where there is short and normal jump is already possible to be forced.

?

matefkr: I think I understand what you are asking now. Because of the 'd' bit we can swap the reg and r/m fields and invert the d bit to get the same effective operation but encoded differently.

Is that what you want to have control over?

Revolution: Indeed also this one, but not just that one. so every kind of encoding an instruction should be separate mnemonic or prefix at lest. so to make it more close to hex coding, but with mnemonics and stuff.

I have previously discussed this in PM before with another poster on this board.

Inventing new custom mnemonics might alienate new users to assembly. Perhaps there is a way where you can use just the operands to describe the desired order of placement in the encoding. e.g.: Perhaps you can think of a "nicer" way to do it.

it might be possible with a sort of macro + maybe modifications of fasm preprocessor + a lot of things very strange to identify.

matefkr
There's a thing called "epimorphic assembler". It's implemented as a macro altm for an assembly/disassembly engine provided there. It allows to choose different opcodes for same mnemonic which could be helpful, if you need a binary identical reassembly, but it uses a numeric encoding scheme instead of providing additional mnemonics which is not quite human-friendly (however, it's also hard to do it better). You could use the same encoding scheme to implement a fasm macro with same capabilities.

FASM always generates the smallest instruction format: jmp i8, push i8 (extended to 32), etc, and register (opcode+r) and al/ax/eax specific versions that do not have a modr/m or [s*i+b] byte. Why would you want it to do anything else?

As for custom instructions, it's very easy to encode them manually if you know Intel machine code. Example: