Is it possible to multiply by an immediate with mul in x86 Assembly?

Question

I am learning assembly for x86 using DosBox emulator. I am trying to perform multiplication. I do not get how it works. When I write the following code:

mov al, 3
mul 2

I get an error. Although, in the reference I am using, it says in multiplication, it assumes AX is always the place holder, therefore, if I write:

mul, 2

It multiplies al value by 2. But it does not work with me.

When I try the following:

mov al, 3
mul al,2
int 3

I get result 9 in ax. See this picture for clarification:

Another question: Can I multiply using memory location directly? Example:

mov si,100
mul [si],5

Answer 1

Intel manual

The Intel 64 and IA-32 Architectures Software Developer’s Manual - Volume 2 Instruction Set Reference - 325383-056US September 2015 section "MUL - Unsigned Multiply" column Instruction contains only:

MUL r/m8
MUL r/m8*
MUL r/m16
MUL r/m32
MUL r/m64

r/mXX means register or memory: so immediates (immXX) like mul 2 are not allowed in any of the forms: the processor simply does not support that operation.

This also answers the second question: it is possible to multiply by memory:

x: dd 0x12341234
mov eax, 2
mul dword [x]
; eax == 0x24682468

And also shows why things like mul al,2 will not work: there is no form that takes two arguments.

As mentioned by Michael however, imul does have immediate forms like IMUL r32, r/m32, imm32 and many others that mul does not.

Answer 2

There's no immediate mul, but there is non-widening imul-immediate in 186 and newer, and imul reg, r/m in 386 and newer. See @phuclv's answer on problem in understanding mul & imul instructions of Assembly language for more details, and of course Intel's instruction set reference manuals for mul and imul:

• https://www.felixcloutier.com/x86/imul - one-operand widening dating back to 8086, and newer more efficient and convenient forms that don't use DX:AX as an implicit destination.
• https://www.felixcloutier.com/x86/mul - only one-operand widening form that's existed since 8086

There's no memory-destination mul or imul even on the newest CPUs.

There is imul cx, [si], 5 if you want, though, on 186 and newer, for 16-bit operand-size and wider. And on 386, also imul di, [si].

But those new forms of imul don't exist for 8-bit operand-size, so there is no imul cl, [si], 5.

On a 386 or newer, it would typically be more efficient to use an LEA for a multiply by a simple constant, although it does cost a bit more code-size.

; assuming 16-bit mode
    mov  cx, [si]              ; or better movzx ecx, word [si] on newer CPUs
    lea  cx, [ecx + ecx*4]     ; CX *= 5