How do you push a byte?

[e]sp is nothing more than a pointer. You're over thinking it.

What manual chapter and section are you referring to?

6.2.2 Stack Alignment
The stack pointer for a stack segment should be aligned on 16-bit (word) or 32-bit
(double-word) boundaries, depending on the width of the stack segment. The D flag
in the segment descriptor for the current code segment sets the stack-segment width
(see “Segment Descriptors” in Chapter 3, “Protected-Mode Memory Management,” of
the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A).
The PUSH and POP instructions use the D flag to determine how much to decrement
or increment the stack pointer on a push or pop operation, respectively. When the
stack width is 16 bits, the stack pointer is incremented or decremented in 16-bit
increments; when the width is 32 bits, the stack pointer is incremented or decremented
in 32-bit increments. Pushing a 16-bit value onto a 32-bit wide stack can
result in stack misaligned (that is, the stack pointer is not aligned on a doubleword
boundary). One exception to this rule is when the contents of a segment register (a
16-bit segment selector) are pushed onto a 32-bit wide stack. Here, the processor
automatically aligns the stack pointer to the next 32-bit boundary.
The processor does not check stack pointer alignment. It is the responsibility of the
programs, tasks, and system procedures running on the processor to maintain
proper alignment of stack pointers. Misaligning a stack pointer can cause serious
performance degradation and in some instances program failures.

Note that you can't do PUSH AL or push 8-byte operand. These instructions do not exist on x86 (in "32-bit mode").

MazeGen wrote:

Note that you can't do PUSH AL or push 8-byte operand. These instructions do not exist on x86 (in "32-bit mode").

They don't exist in "16-bit mode", real or protected, either. They just don't exist

fasmnewbie, there is no X86 instruction to push a byte.

You must push a word, doubleword etc. - always an even number of bytes.

Then if SP is word-aligned, (even address) there is no misalignment problem.

fasmnewbie, it is hard to learn about x86 from the manuals. Get a debugger and start stepping your code to see what's happening.

I assume you're using 32-bit version of Windows or *nix. That means your stack is 32 bits wide. At the program startup the stack is aligned to 32 bits. In the source code, PUSH 0x12 actually means PUSH 0x00000012, and PUSH 0x1234 means PUSH 0x00001234 so the stack keeps its alignment. You can explicitly declare that you want to push 16-bit constant, but it is rarely used. You can also PUSH AX that misalignes the stack. Again, there is no point in pushing 16-bit registers to 32-bit stack in everyday programming. (You can PUSH WORD [EAX], too.)

Note that you can't do PUSH AL or push 8-byte operand. These instructions do not exist on x86 (in "32-bit mode").

Only that not all data are double-word 'aligned'. If lets say I pushed 3 word-sized data on the 32-bit wide stack, that means memory spaces are wasted to the same amount. I see your point why there is no practical reason to push word on double-word stack. But the inefficiency is still there if smaller data are pushed.

For example, what if my program is non-string chars-intensive. I mean chars would have to be pushed onto the stack anyway. Word-padding the 8-bit chars would seem wasting.

Or did I get this wrong?

SUB ESP, 1
MOV BYTE [ESP], <8-bit register/constant>    

push dword myHelloSample

;using later in the code:
mov eax,[esp] ; if you want the address to remain on stack
; or
pop  eax ; finally balance the stack

myHelloSample db "Hello World!",0
    

fasmnewbie wrote:

Only that not all data are double-word 'aligned'. If lets say I pushed 3 word-sized data on the 32-bit wide stack, that means memory spaces are wasted to the same amount. I see your point why there is no practical reason to push word on double-word stack. But the inefficiency is still there if smaller data are pushed.

For example, what if my program is non-string chars-intensive. I mean chars would have to be pushed onto the stack anyway. Word-padding the 8-bit chars would seem wasting.

Or did I get this wrong?

You're right.

The thing is that PUSH is in most cases used to pass function arguments to stack. If you have 16-bit arguments, you can pass them as such but it is unusual because you would waste only few 16-bit chunks of memory. And it is unusual to misaling the stack at the function entry so in case of odd number of 16-bit arguments stack adjustment would be needed.

If you have 8-bit arguments, you would additionally have to pack them somehow since you can't PUSH them directly. Well, you could do

Code:

SUB ESP, 1
MOV BYTE [ESP], <8-bit register/constant>    

Again, this would be very unusual way to pass 8-bit argument.

On the other hand, it is usual to allocate stack using SUB ESP, x, for example for local (automatic) variables in function prolog. But that's another story.

@fasmnewbie: If you're thinking about pushing "Hello World!" on the stack then quickly forget that idea
The most efficient way to use stack is to push the address of the string but not the string one-by-one (push "H" "e" "l" ... "d" "!").

Code:

push dword myHelloSample

;using later in the code:
mov eax,[esp] ; if you want the address to remain on stack
; or
pop  eax ; finally balance the stack

myHelloSample db "Hello World!",0