home *** CD-ROM | disk | FTP | other *** search
/ Reverse Code Engineering RCE CD +sandman 2000 / ReverseCodeEngineeringRceCdsandman2000.iso / RCE / LordLucifer / win32asm / files / win32asm.exe / Win32ASM / ASMInc / Instr32.mac < prev    next >
Encoding:
Text File  |  1997-09-02  |  9.7 KB  |  306 lines
  1. ; Macros definition file (instruction / directives extensions).
  2.  
  3. ; $Id: Instr32.mac 1.2 1997/09/02 11:39:24 Philippe Exp $
  4.  
  5. ; $Log: /Win32Equ/Instr32.mac $
  6. ; 
  7. ; 1     18/09/97 14:24 Philippe
  8. ; Initial checkin into SourceSafe.
  9. ; Revision 1.2  1997/09/02 11:39:24  Philippe
  10. ; Added HighItem optional parm to ENUMEND macro.
  11. ;
  12. ; Revision 1.1  1997/09/02 09:50:38  Philippe
  13. ; Initial revision
  14. ;
  15.  
  16.  
  17.  
  18. ; MASM 6.x Structured coding directives extensions.
  19.  
  20.     OPTION DOTNAME                      ;Allow names such as .BLOCK
  21.     OPTION PROC:PRIVATE                 ;PROCs are private by default.
  22.  
  23. ; The .BLOCK/.ENDBLOCK directives provide a non-looping, non generating
  24. ; frame that can be used for generating a block with multiway exits to
  25. ; a single point (thru .BREAK .IF <condition> directives).
  26.  
  27. .BLOCK          MACRO                   ;; Begin code block.
  28.                 .REPEAT
  29.                 ENDM
  30.  
  31. .ENDBLOCK       MACRO                   ;; End code block.
  32.                 .UNTIL 1                ;; (Generates no code.)
  33.                 ENDM
  34.  
  35.  
  36. ; More readable/explicit than .UNTIL 0 or .UNTIL FALSE.
  37.  
  38. .FOREVER        MACRO                   ;; Loop forever (.REPEAT / .FOREVER)
  39.                 .UNTIL 0                ;;
  40.                 ENDM
  41.  
  42. ; The Microserfs who did MASM didn't take the obvious decision of simply
  43. ; deriving the Intel J<cond> mnemonics for simple condition testing in their
  44. ; structured programming directive (like allowing .IF AE?, .WHILE GE?,
  45. ; .UNTIL BE?, .BREAK .IF A?, whatever...).
  46. ; So it looks like there is no simple way to use the directives to generate
  47. ; some of the jumps from preexisting conditions.
  48. ; But for those that are supported (and their NOT form), here are a few
  49. ; additional mnemonics:
  50.  
  51. EQUAL?          TEXTEQU <ZERO?>
  52. BELOW?          TEXTEQU <CARRY?>
  53. ABOVEorEQUAL?   TEXTEQU <!!CARRY?>
  54.  
  55.  
  56.  
  57. ; This macro because of a silly bug in MASM:
  58. ; MASM does generate a LINK directive in a module object code that has an
  59. ; END Label
  60. ; directive. The problem is, it does it wrong <sigh>.
  61. ; If an STDCALL directive is in effect, and the entry procedure is Start,
  62. ; the "END Start" directive will generate an inline
  63. ; /Entry:_Start"
  64. ; directive.
  65. ; Now, note that LINK will in turn decorate the name and internally change
  66. ; it to "__Start", that it expects to be a PUBLIC in the object file.
  67. ; The net result is that an END Start will generate a reference to __Start.
  68. ;
  69. ; Strike 2: There can't be neither _Start nor __Start defined in the MASM
  70. ; module, because the use of STDCALL will change any "Start" PROC
  71. ; in the source into a PUBLIC reference of _Start@0.
  72. ; So we endup with MASM declaring _Start@0 and referencing __Start.
  73. ; The error here is in the embedded link directive the END statement generates.
  74. ; If MASM were consistent with itself, it would apply the default interface
  75. ; convention for the module to the END directive, thus generating an inline
  76. ; /Entry:_Start@0
  77. ; link directive for everything to be fine. But even though MASM is not
  78. ; consistent with itself, we can fix the problem, by replacing the END
  79. ; directive with the following Entry macro:
  80. ;   ENTRY Start
  81. ; This macro will only work with the STDCALL parms convention (the one Win32
  82. ; uses). It would be easy to test for the parm passing model and generate
  83. ; the proper code for other conventions.
  84.  
  85. ENTRY MACRO EntryPoint:REQ
  86.       LOCAL EntryPoint
  87.         IF @Version GE 611
  88.         ALIAS <_&EntryPoint&@0>=<&EntryPoint>
  89.         ENDIF
  90.       END &EntryPoint
  91.       ENDM
  92.  
  93.  
  94. ; SAVE & RESTORE. - Ph.A., 16.05.86.
  95. ; SAVE   : Save registers to the stack.
  96. ; RESTORE: Restore registers from the stack.
  97. ; RESTORE generates POPs from the parm list in backward order, so the same
  98. ; list that was used for a SAVE can be used to restore the registers to
  99. ; their SAVED values.
  100. ; Changed to generate PUSHFD / POPFD for 32 bits.
  101.  
  102. SAVE MACRO R1,R2,R3,R4,R5,R6,R7,R8,R9,R10,R11,TESTARG
  103.     .ERRNB <TESTARG>    ;Too many things to push.
  104.       IFNB <R1>
  105.         IFIDNI <R1>,<F>
  106.           PUSHFD
  107.         ELSE
  108.           PUSH R1
  109.         ENDIF
  110.           SAVE R2,R3,R4,R5,R6,R7,R8,R9,R10,R11
  111.       ENDIF
  112.     ENDM
  113.     .XCREF SAVE
  114.  
  115. RESTORE MACRO R11,R10,R9,R8,R7,R6,R5,R4,R3,R2,R1,TESTARG
  116.     .ERRNB <TESTARG>                    ;Too many things to pop.
  117.       IFNB <R11>
  118.           RESTORE R10,R9,R8,R7,R6,R5,R4,R3,R2,R1
  119.         IFIDNI <R11>,<F>
  120.           POPFD
  121.         ELSE
  122.           POP R11
  123.         ENDIF
  124.       ENDIF
  125.     .CREF
  126.     ENDM
  127.     .XCREF RESTORE
  128.  
  129.  
  130. ; Dummy macro used to suppress MASM warning about unused parms (declared
  131. ; in function headers but actually not used in a proc).
  132.  
  133. UnusedParm      Macro ParmName:REQ
  134.                 Local Dummy
  135. Dummy           EQU ParmName            ;Fool MASM by using parm.
  136.                 ENDM
  137.  
  138.  
  139. ; MUSTBE & SHOULDBE macros - Ph.A., 26.05.86.
  140.  
  141. ; MUSTBE & SHOULDBE are called with a valid condition mnemonic value, such
  142. ; as A, NZ, NGE. If the required condition is not met, MUSTBE calls the
  143. ; FATALERR routine, which is a no-return, ABEND type of routine, and SHOULDBE
  144. ; calls the WARNING routine, which would probably be implemented as a snapshot
  145. ; dump or trace routine, and would return control.
  146.  
  147. MUSTBE MACRO C1
  148.     Local Around
  149.     FatalError PROTO STDCALL MsgAddr:DWORD
  150.     IFNB <C1>
  151.      J&C1 SHORT Around                  ;Jump around lethal call.
  152.     ENDIF
  153.     INVOKE FatalError,0                 ;Die horribly.
  154.     IFNB <C1>
  155. Around:
  156.     ENDIF
  157.     ENDM
  158.     .XCREF MUSTBE
  159.  
  160.  
  161. MUSTBEM MACRO C1,MSG
  162.     Local szMsg,Around
  163.     FatalError PROTO STDCALL MsgAddr:DWORD
  164.     .XCREF
  165.     IFNB <C1>                           ;If cond defined and met,
  166.     J&C1 Around                         ;Jump around jump the lethal call
  167.     ENDIF
  168.      IFB <MSG>
  169.      INVOKE FatalErr,0                  ;No error message this time
  170.      ELSE
  171.      .CONST
  172.      BYTE SIZEOF szMsg
  173. szMsg BYTE MSG,0                        ;Give error msg.
  174.      .CODE
  175.      INVOKE FatalError,ADDR szMsg
  176.      ENDIF
  177.     IFNB <C1>
  178. Around:
  179.     ENDIF
  180.     ENDM
  181.     .XCREF MUSTBEM
  182.  
  183. MUSTBEMGLE MACRO C1,MSG
  184.     Local szMsg,Around
  185.     FatalErrorGLE PROTO STDCALL MsgAddr:DWORD
  186.     .XCREF
  187.       IFNB <C1>                         ;If cond defined and met,
  188.       J&C1 Around                       ;Jump around jump the lethal call
  189.       ENDIF
  190.       IFB <MSG>
  191.       INVOKE FatalErrorGLE,0
  192.       ELSE
  193.       .CONST
  194.       BYTE SIZEOF szMsg
  195. szMsg BYTE MSG,0                        ;Give error msg
  196.       .CODE
  197.       INVOKE FatalErrorGLE,ADDR szMsg
  198.       ENDIF
  199.     IFNB <C1>
  200. Around:
  201.     ENDIF
  202.     ENDM
  203.     .XCREF MUSTBEMGLE
  204.  
  205.  
  206. SHOULDBE MACRO C1
  207.     Local Around
  208.     Warning PROTO STDCALL
  209.     IFNB <C1>
  210.      J&C1 SHORT Around                  ;Jump around warning call.
  211.     ENDIF
  212.     INVOKE Warning                      ;Indicate some strange condition.
  213.     IFNB <C1>
  214. Around:
  215.     ENDIF
  216.     ENDM
  217.     .XCREF SHOULDBE
  218.  
  219.  
  220. ; Define enumerated, sequential equate values.
  221. ; Useful for defining indices or offset into tables.
  222. ; Example of use:
  223. ;
  224. ;    ENUM WORD
  225. ;      ENUMITEM FBTxStIdle              ;TXer does plenty of nothing.
  226. ;      ENUMITEM FBTxStHead2             ;About to send 'B', second header byte.
  227. ;      ENUMITEM FBTxStData              ;About to send a data byte.
  228. ;      ENUMITEM FBTxStCRC8              ;TxEr about to send CRC-8 (negociation).
  229. ;      ENUMITEM FBTxStCRC16L            ;TxEr about to send CRC-16, LSB
  230. ;      ENUMITEM FBTxStCRC16M            ;TxEr about to send CRC-16, MSB
  231. ;      ENUMITEM FBTxStDLEd              ;TXer about to send DLE'd data.
  232. ;      ENUMITEM FBTxStRing              ;Transmitting from ring buffer.
  233. ;      ENUMITEM FBTxStChain             ;Txer about to check for chained
  234. ;                                       ;transmission.
  235. ;    ENUMEND Foo                        ;Foo (optional arg) is a symbol that
  236. ;                                       ;will be equated to the value
  237. ;                                       ;of the highest item generated.
  238.  
  239.  
  240. ENUM            MACRO ItemType:REQ
  241.                 LOCAL ItemType
  242.                 IFDEF $$$ItemValue
  243.                 .ERRNZ $$$ItemValue - (-1) ; Wrong ENUM macros nesting
  244.                 ENDIF
  245. $$$ItemSize   = SIZEOF ItemType
  246. $$$ItemValue  = 0
  247.                 ENDM
  248.  
  249. ENUMITEM        MACRO ItemName:REQ
  250.                 LOCAL ItemName
  251.                 .ERRNZ ($$$ItemValue EQ -1)  ;Missing ENUM macro.
  252. ItemName        = $$$ItemValue
  253. $$$ItemValue    = $$$ItemValue + $$$ItemSize
  254.                 ENDM
  255.  
  256. ENUMEND         MACRO HighItem
  257.                 Local HighItem
  258.                 IFNB <HighItem>              ;If HighItem is defined,
  259. HighItem        = $$$ItemValue - $$$ItemSize ;Equate the symbol with highitem
  260.                 ENDIF                        ;value.
  261.                 .ERRNZ ($$$ItemValue EQ -1)  ;Wrong ENUM macros nesting.
  262. $$$ItemValue    = -1
  263.                 ENDM
  264.  
  265.  
  266. ; For compatibility with older stuff.
  267. ; For long strings, use the MEMMOVE routine that moves aligned DWORDs
  268.  
  269. BXFER MACRO
  270.       REP MOVSB
  271.       ENDM
  272.  
  273.  
  274. ; Breakpoint instructions. Ph.A.
  275. ; Breakpoint may be implemented thru INT 3 (one byte interrupt) or INT 2
  276. ; (NMI).
  277.  
  278. BREAK MACRO
  279.     INT 3                               ;Use Breakpoint interrupt.
  280.     ENDM
  281.     .XCREF BREAK
  282.  
  283. DEBUG MACRO
  284.     INT 1                               ;Use Debugger Call interrupt.
  285.     ENDM
  286.     .XCREF DEBUG
  287.  
  288. NMI MACRO
  289.     INT 2                               ;Use NMI interrupt.
  290.     ENDM
  291.     .XCREF NMI
  292.  
  293.  
  294. ; For use between back-to-back I/O to the same chip (for AT compatibility).
  295. ; Should add yet another JMP SHORT $+2 to make provision for fast processors
  296. ; and slow busses (it purges the instruction prefetch queue).
  297. ; How much of these will we need for 486 ?!
  298. ; Is this still enough with 586 branch prediction ? Ph.A.
  299.  
  300. IODELAY MACRO
  301.     JMP SHORT @F
  302. @@:
  303.     ENDM
  304.     .XCREF IODELAY
  305.  
  306.