masm32

Can't output coprocessor float from variable two times in a row

谁说胖子不能爱 — Fri, 29 Jan 2021 06:35:55 +0000

Can't output coprocessor float from variable two times in a row 谁说胖子不能爱 2021-01-29 14:35:55

问题

Good afternoon! In this example, I simply add two numbers with a comma, save the variable in tbyte and display the same variable two times in a row on the screen, but the first time I get 11.1, as it should be, and the second time 4.667261E-062. Why is this happening?

And one more question, is it possible in tbyte to somehow save and access numbers by array type? for example, storing numbers in dd, I just could save and read them in increments of 4, for example, result [0], result [4], etc. Is it possible to use the same with tbyte and how? If I understand right - it should be a step of 10.

.386
.model flat,stdcall
option casemap:none

include \masm32\include\masm32rt.inc

.data
titletext db  'Title',0
frmt db 'Result1 = %.7G',10
     db 'Result2 = %.7G',0
buff db 1024 dup (?)
result tbyte ?
num1 qword 5.5
num2 qword 5.6

.code
start:
    finit
    fld qword ptr [num1]
    fld qword ptr [num2]
    fadd
    fstp qword ptr [result]

    invoke crt_sprintf,addr buff,addr frmt, result, result
    invoke MessageBox,0,addr buff,addr titletext,MB_OK
    invoke ExitProcess,0
end start

回答1:

Why are you doing a fstp qword (double) into a tbyte (long double)?

Oh, that's probably your bug. Presumably the invoke macro pushes 12 bytes for each of the result macro args. (Because a 10-byte tbyte padded to a multiple of 4-byte stack slots is 12).

But your format string only tells sprintf to look for double args, which are 8 bytes wide. Since you only stored a qword double to the low 8 bytes of result, crt_sprintf can correctly read the first variadic arg as a double. (x86 is little-endian so the low 8 bytes are at the stack address sprintf is looking at.)

But the 2nd %G conversion will be looking for another double right after the end of the previous arg. Which according to the format string should be 8 bytes later. But what your invoke actually pushed didn't match that. So the 2nd %G reads 8 bytes that overlap the two 12-byte pushes.

It's probably 0 in the upper 4 bytes (including exponent and sign bit), and non-zero only in the low 31 bits of the mantissa, giving you a very small subnormal number. You can use a debugger to examine memory as a double and see that it represents the value sprintf read.

If long double in that C library is the 10 byte x87 type, use %LG and use fstp tbyte.

If sizeof(long double) is only 8, then it's the same as double and you can't printf x87 tbyte values with that C library. (Unless it has some non-standard extension for it.) In that case You just change result to also be a qword, matching the store you're doing.

Also, you didn't balance the x87 stack; use faddp so it's empty after the fstp. (If your assembler requires an operand, use faddp st(1) or st1, however it likes to spell x87 register names.)

You're technically violating the calling convention by making a function call with the x87 stack non-empty, but apparently crt_sprintf doesn't use all 8 of st0..7 so it doesn't get a NaN from overflowing the x87 stack.

来源：https://stackoverflow.com/questions/60887371/cant-output-coprocessor-float-from-variable-two-times-in-a-row

标签

assembly

x86

MASM

masm32

x87

x86 MASM Assembly - Input Buffer holds old input despite FlushConsoleInputBuffer

余生长醉 — Thu, 28 Jan 2021 01:18:04 +0000

x86 MASM Assembly - Input Buffer holds old input despite FlushConsoleInputBuffer 余生长醉 2021-01-28 09:18:04

问题

To practice assembly in MASM, I created a small program that is supposed to do the do the following:

Print "Type a: " to the screen
Read one character from the input buffer, which is then flushed
If the character is "a", then break away from the loop and end the program, if otherwise, repeat from step one

My code goes as follows:

.386


.model flat,stdcall


include \masm32\include\kernel32.inc ; Defines Symbols To Be Used for the kernel32 library


includelib \masm32\lib\kernel32.lib



STD_OUTPUT_HANDLE equ -11
STD_INPUT_HANDLE equ -10

.code



entryPt proc
    local inHandle:DWORD
    local outHandle:DWORD
    local noOfCharsWritten:DWORD
    ; Get Standard Output Handle
    push STD_OUTPUT_HANDLE
    call GetStdHandle
    mov outHandle,eax

    ; Get Standard Input Handle
    push STD_INPUT_HANDLE
    call GetStdHandle
    mov inHandle,eax

    .while (eax == eax) ; while (true)

        ; Print "Type a: "
        push 0
        lea eax,noOfCharsWritten
        push eax
        push sizeof txt
        push offset txt
        push outHandle
        call WriteConsoleA

        ; Poll for a byte
        call getChar

        .if (al == "a") ; if the byte was "a"...
            .break ; ...then end the loop
        .endif

    .endw

    ; Leave with exit code 0
    push 0
    call ExitProcess
entryPt endp

getChar proc
    local inHandle:DWORD
    local noOfCharsRead:DWORD
    local resBt:BYTE
    ; Get the Standard Input Handle
    push STD_INPUT_HANDLE
    call GetStdHandle
    mov inHandle,eax
    ; Read one char from the console, put the result in resBt and the number of chars read in noOfCharsRead
    push 0
    lea eax,noOfCharsRead
    push eax
    push 1
    lea eax,resBt
    push eax
    push inHandle
    call ReadConsoleA

    ; Flush Console Input Buffer
    push inHandle
    call FlushConsoleInputBuffer

    ; Return the result in the accumulator
    movzx eax,resBt
    ret
getChar endp
.data

txt db "Type a: "

end entryPt

When typing "a", the program will exit, just like it should. However, should I type anything that is not "a" (for example, "s"), instead of inquiring "Type a: " again, only once, it will instead write "Type a: Type a: Type a:" before inquiring for another byte. Writing more than one non-a character will result in even more "Type a: "s.

I suspect this is because ReadConsole is reading the older input and therefore terminating the function early, but shouldn't FlushConsoleInputBuffer have cleaned out the old input?

回答1:

ReadConsole reads all available characters from the console input buffer and stores them in a separate buffer that is not affected by FlushConsoleInputBuffer. You haven't a direct access to that buffer and can't get information about it. So, you have to read it with ReadConsole until the end of the line. By default, the end of the line is marked with the two bytes CR (0x0D) and LF (0x0A). Since you read just one byte, there is left at least the LF in the buffer.

Replace the FlushConsoleInputBuffer with a ReadConsole loop to empty the buffer until LF is read:

.model flat,stdcall

include \masm32\include\kernel32.inc ; Defines Symbols To Be Used for the kernel32 library
includelib \masm32\lib\kernel32.lib

STD_OUTPUT_HANDLE equ -11
STD_INPUT_HANDLE equ -10

.code

entryPt proc
    local inHandle:DWORD
    local outHandle:DWORD
    local noOfCharsWritten:DWORD
    ; Get Standard Output Handle
    push STD_OUTPUT_HANDLE
    call GetStdHandle
    mov outHandle,eax

    ; Get Standard Input Handle
    push STD_INPUT_HANDLE
    call GetStdHandle
    mov inHandle,eax

    .while (eax == eax) ; while (true)

        ; Print "Type a: "
        push 0
        lea eax,noOfCharsWritten
        push eax
        push sizeof txt
        push offset txt
        push outHandle
        call WriteConsoleA

        ; Poll for a byte
        call getChar

        .if (al == "a") ; if the byte was "a"...
            .break ; ...then end the loop
        .endif

    .endw

    ; Leave with exit code 0
    push 0
    call ExitProcess
entryPt endp

getChar proc
    local inHandle:DWORD
    local noOfCharsRead:DWORD
    local resBt:BYTE, dummy:BYTE

    ; Get the Standard Input Handle
    push STD_INPUT_HANDLE
    call GetStdHandle
    mov inHandle,eax

    ; Read one char from the console, put the result in resBt and the number of chars read in noOfCharsRead
    push 0
    lea eax,noOfCharsRead
    push eax
    push 1
    lea eax,resBt
    push eax
    push inHandle
    call ReadConsoleA

    ; Flush
    mov al, resBt
    mov dummy, al
    FlushLoop:
    cmp dummy, 0Ah
    je EndOfFlush
    invoke ReadConsoleA, inHandle, ADDR dummy, 1, ADDR noOfCharsRead, 0
    jmp FlushLoop
    EndOfFlush:

    ; Return the result in the accumulator

    movzx eax,resBt
    ret
getChar endp
.data

txt db "Type a: "

end entryPt

来源：https://stackoverflow.com/questions/53684281/x86-masm-assembly-input-buffer-holds-old-input-despite-flushconsoleinputbuffer

标签

x86 assembly extreme novice inquiry: “invalid instruction operands”?

岁酱吖の — Sun, 29 Nov 2020 02:09:03 +0000

x86 assembly extreme novice inquiry: “invalid instruction operands”? 岁酱吖の 2020-11-29 10:09:03

问题

The code below is only a small fraction of the program I am currently attempting to write, but no other parts of the program are relevant, so I only pasted what was necessary. Anyway, what I am trying to do is move the value stored within inputLoopCounter into ecx in order to determine how many times a loop should execute. However, when I attempt to assemble this program, I get the error mentioned in the question title. Can anybody explain the reason for this?

.data
inputLoopCounter BYTE -1

.code
mov   ecx,inputLoopCounter

回答1:

One possible solution would be to replace inputLoopCounter BYTE -1 by inputLoopCounter DWORD -1.

回答2:

In MASM, foo BYTE -1 is treated as declaring a "variable" with a fixed size. Using that symbol later implies an operand-size for instructions that access it.

So MASM is trying to save you from yourself, stopping you from doing a dword (4-byte) load from a 1-byte variable. This happens even if you have multiple bytes, like foo db "foobar" and want to load multiple characters; that's when mov eax, dword ptr [foo] is useful.

The other major flavour of Intel-syntax assembly language (NASM), will happily assemble an instruction that loads 4B from [inputLoopCounter], regardless of what inputLoopCounter is a label for.

In NASM, mov [inputLoopCounter], 0 is a syntax error, because there's no implied operand-size from either operand. (And in MASM, it would be a mov byte ptr [inputLoopCounter], 0.)

semi-related: Confusing brackets in MASM32 - foo ptr [123] works as an alternative to ds:123 for indicating a memory operand, not an immediate, where insanely [123] would still be an immediate. Also related: Assembly difference between [var], and var

If MASM allows it in the data section, foo: db ... would just declare a label without an implied size, separate from any data declaration.

But apparently MASM does not support that in the data section, so you're stuck with variables, unless you want to switch assemblers. How to store 4 characters in a define doubleword in assembly language?

来源：https://stackoverflow.com/questions/37034904/x86-assembly-extreme-novice-inquiry-invalid-instruction-operands

标签

assembly

x86

masm32

x86 assembly extreme novice inquiry: “invalid instruction operands”?

…衆ロ難τιáo~ — Sun, 29 Nov 2020 02:08:44 +0000

x86 assembly extreme novice inquiry: “invalid instruction operands”? …衆ロ難τιáo~ 2020-11-29 10:08:44

问题

.data
inputLoopCounter BYTE -1

.code
mov   ecx,inputLoopCounter

回答1:

One possible solution would be to replace inputLoopCounter BYTE -1 by inputLoopCounter DWORD -1.

回答2:

In MASM, foo BYTE -1 is treated as declaring a "variable" with a fixed size. Using that symbol later implies an operand-size for instructions that access it.

The other major flavour of Intel-syntax assembly language (NASM), will happily assemble an instruction that loads 4B from [inputLoopCounter], regardless of what inputLoopCounter is a label for.

In NASM, mov [inputLoopCounter], 0 is a syntax error, because there's no implied operand-size from either operand. (And in MASM, it would be a mov byte ptr [inputLoopCounter], 0.)

If MASM allows it in the data section, foo: db ... would just declare a label without an implied size, separate from any data declaration.

来源：https://stackoverflow.com/questions/37034904/x86-assembly-extreme-novice-inquiry-invalid-instruction-operands

标签

assembly

x86

masm32

Confusing brackets in MASM32

北慕城南 — Mon, 23 Mar 2020 00:18:12 +0000

Confusing brackets in MASM32 北慕城南 2020-03-23 08:18:12

问题

I am trying to get to grips with MASM32 and am confused by the following:

I thought that brackets were used for indirection so if I have the a pre-defined variable

 .data
   item dd 42

then

 mov ebx, item

would put the contents of 'item', i.e. the number 42, into ebx and

 mov ebx, [item]

would put the address of 'item', i.e. where the 42 is stored, into ebx.

But the following code in a console app:

 mov ebx, item
 invoke dwtoa, ebx, ADDR valuestr 
 invoke StdOut, ADDR valuestr
 mov ebx, [item]
 invoke dwtoa, ebx, ADDR valuestr 
 invoke StdOut, ADDR valuestr

prints 42 twice. To get the address of 'item' I seem to need

 mov ebx, [OFFSET item]
 invoke dwtoa, ebx, ADDR valuestr 
 invoke StdOut, ADDR valuestr

Can anybody explain what square brackets are for in MASM, or point me at a good reference.

回答1:

MASM is unusual for an assembly language in that is has types. MASM knows because of how you defined the symbol item that is a memory location of type DWORD. When you use it as an operand knows that you (probably) mean that you want the value stored at the address, not the value of the address. So it doesn't matter if you use item or [item] MASM assumes you mean the later. If you really want the address of item instead you need to use OFFSET item.

On the other hand if you had defined item as constant using item = 42 then mov ebx, item would load the immediate value. Because of this ambiguity, you need to know how item was defined to determine if it's an immediate operand or a memory operand, it's good idea to avoid using a bare symbol as an operand.

I should add that the square brackets [] mean pretty much nothing to MASM when you're just using symbols or numbers. They only mean something when you use them with registers. Here's some examples:

item    DD  42
const   =   43

    mov eax, item             ; memory operand (the value stored at item)
    mov eax, [item]           ; memory operand
    mov eax, OFFSET item      ; immediate operand (the address of item)
    mov eax, [OFFSET item]    ; immediate operand

    mov eax, const            ; immediate operand (43)
    mov eax, [const]          ; immediate operand
    mov eax, ds:[const]       ; memory operand (the value at address 43)
    mov eax, fs:30h           ; memory operand (the value at address 30h + fs base)
    mov eax, OFFSET const     ; immediate operand
    mov eax, [OFFSET const]   ; immediate operand

    mov eax, 42               ; immediate operand
    mov eax, ebx              ; register operand (the value of EBX)
    mov eax, [ebx]            ; indirect operand (the value pointed to by EBX)

So without registers square brackets only show your intent. You should put square brackets around symbols if you intend to use them as memory operands, and use OFFSET with symbols you intend to use as immediate values.

来源：https://stackoverflow.com/questions/60479552/difference-between-two-instructions-mov-eax-dword-ptr-fs30h-and-mov-eax-la

标签

assembly

MASM

masm32

How do I write letter-initiated hexadecimal numbers in masm code?

点点圈 — Sun, 16 Feb 2020 02:30:08 +0000

How do I write letter-initiated hexadecimal numbers in masm code? 点点圈 2020-02-16 10:30:08

问题

I am currently editing several macros consisting of MASM code. They all look similar to this:

Primary MACRO
Key 0Bh,'0'
Key 29h,15h
Key 03h,'2'
Key 06h,'5'
Key 0Ch,'+'
Key 0Dh,'´'
Key 1Bh,'¨'
Key 2Bh,27h
Key 35h,'-'
Key 34h,'.'
Key 33h,','
Key 56h,'<'
ENDM

I have noticed that I can write hexadecimal numbers which are initiated by (begin with) character 0-9 in the following format: 02h, 12h, 5Ah, etc. However, if I try to write letter-initiated hexadecimal numbers in the same way (that is, like ABh, CAh, DFh, etc.), I get an error. I have tried the format 0xBA, 0xFE, etc., but it doesn't work either.

Can anyone tell me the correct format to use for writing letter-initiated hexadecimal numbers in this case?

回答1:

The correct format for hex AB is 0ABh.

The reason you need to start it with a digit is so the assembler can easily distinguish it from a label or symbol such as ABh.

And don't worry about the fact it has three digits. It doesn't magically turn into a twelve-bit number because of that, the number of bits used will depend on the addressing modes you're using.

来源：https://stackoverflow.com/questions/33276232/how-do-i-write-letter-initiated-hexadecimal-numbers-in-masm-code

标签

assembly

hex

masm32

Displaying Graphics in BIOS

99封情书 — Thu, 16 Jan 2020 10:57:08 +0000

Displaying Graphics in BIOS 99封情书 2020-01-16 18:57:08

问题

Using MASM32 is it possible to display bitmaps stored in a binary file embedded with the executable to the console?

Can anyone show me how?

Addendum: I'm not talking about a full fledge GUI here. Just the ability to display character bitmaps on the screen. They would be stored as 8x8 binary images in a file that we link to the executable.

回答1:

You can do anything using MASM you could do with C or C++. However, using MASM doesn't give you any special abilities (you will still need to access the filesystem, for example), so if this is an attempt to get round the problems pointed out in answers to your previous question, you are out of luck.

来源：https://stackoverflow.com/questions/2272000/displaying-graphics-in-bios

标签

Displaying Graphics in BIOS

和自甴很熟 — Thu, 16 Jan 2020 10:56:20 +0000

Displaying Graphics in BIOS 和自甴很熟 2020-01-16 18:56:20

问题

Using MASM32 is it possible to display bitmaps stored in a binary file embedded with the executable to the console?

Can anyone show me how?

回答1:

来源：https://stackoverflow.com/questions/2272000/displaying-graphics-in-bios

标签

Float data example using Masm

三世轮回 — Tue, 14 Jan 2020 19:28:11 +0000

Float data example using Masm 三世轮回 2020-01-15 03:28:11

问题

Can somebody give me an example how to define a float number or constant in data section of MASM? Or at least some information about it...

回答1:

I think it's done with

.data
   myVar REAL4  1.0f

.code

Floating point values are REAL4, REAL8 or REAL10 in Masm.
Expressions (such as #define myConst 1.0f) are done with myConst EQU 1.0

These are not specific to any section.

来源：https://stackoverflow.com/questions/13703907/float-data-example-using-masm

标签

assembly

floating-point

masm32

How does MASM .DATA? directive work internally [duplicate]

只愿长相守 — Mon, 13 Jan 2020 08:56:12 +0000

How does MASM .DATA? directive work internally [duplicate] 只愿长相守 2020-01-13 16:56:12

问题

In Kip Irvines book I came across the following :

The .DATA? directive declares uninitialized data. When defining a large block of uninitialized data, the .DATA? directive reduces the size of a compiled program. For example, the followingcode is declared efficiently:

.data?

bigArray DWORD 5000 DUP(?) ; 20,000 bytes, not initialized

The following code, on the other hand, produces a compiled program 20,000 bytes larger:

.data

bigArray DWORD 5000 DUP(?) ; 20,000 bytes

What exactly is the .data? directive doing under the hood in the above example to make the program 20k smaller.

回答1:

The uninitialized data need not be in the compiled binary, just a byte count that the OS loader allocates at run-time when executing your program.

来源：https://stackoverflow.com/questions/7137049/how-does-masm-data-directive-work-internally

标签

assembly

masm32