Liren Large Software Subsidy 9

home *** CD-ROM | disk | FTP | other *** search

/ Liren Large Software Subsidy 9 / 09.iso / l / l224 / 1.img / MANUAL.ZIP / UPDATE.DOC < prev

Wrap

Text File | 1990-10-29 | 19.8 KB | 528 lines

TURBO ASSEMBLER 2.0 NEW FEATURES -------------------------------- Borland's Turbo Assembler 2.0 is now a multi-pass assembler that has forward-reference resolution, assembly speeds of up to 48,000 lines per minute, MASM compatibility, and an optional Ideal mode extended syntax. In addition to all the features of version 1.0, Turbo Assembler 2.0 offers you these: o PUBLICDLL statement o Multiple pass capability - NOP removal o CALL extensions o PUSH, POP instruction extensions o COMM extension o Generalized line-continuation character o Language-specific procedures, extrns, publics o New MODEL identifiers - WINDOWS o Virtual segments o QASM Compatibility Additions o 486 instruction support o New TASM 2.0 error messages o CODEPTR type o RETCODE instruction o SMART/NOSMART directives o Overlay object code PUBLICDLL Statement -------------------- The PUBLICDLL directive lets you define program labels and procedures to be dynamic link entry points as well as publicizing them to your other modules, which allows you to build dynamic link libraries in assembly code. For example, PUBLICDLL XYPROC ;make procedure XYPROC XYPROC PROC NEAR ;accessible as dynamic ;link entry point The syntax for PUBLICDLL follows: PUBLICDLL [language] symbol [,[language] symbol]...} symbol is published in the object file as a dynamic link entry point so that it can be accessed by programs under OS/2. This statement is used only to help build an OS/2 dynamic link library. If you don't make a symbol public, it can only be accessed from the current source file. In most cases, you declare only PROC labels to be PUBLICDLL. Other program labels, data variable names, and numeric constants defined with EQU can also be declared to be PUBLICDLL. The optional language specifier causes any language-specific conventions to be applied to the symbol name. For instance, using the C language specifier would cause the symbol name to be preceded by an underscore character when published in the object file. Valid language specifiers are C, PASCAL, BASIC, FORTRAN, PROLOG, and NOLANGUAGE. COMM, EXTRN, GLOBAL, and PUBLIC are related instructions. Multiple Pass Capability: NOP Removal ------------------------------------- Turbo Assembler 2.0 can pass over your source code more than once either for compatibility with some of MASM's pass-dependent constructions or to remove NOP instructions that were added to the code because of forward references. This feature is enabled by the command-line switch /m#, where # is the maximum number of passes allowed. Turbo Assembler automatically assesses the need to perform extra passes up to the maximum that you specify. The command-line switch /m sets the maximum number of assembly passes: /M[npasses] For maximum compatibility with MASM, two passes (/m2) should be used. If you don't specify the number of passes, a default of five is used. TASM 2.0's new multiple pass capability enhances compatibility with MASM in the following areas: 1) Any construction that generates a "Pass-dependent construction" warning in TASM 1.0. These include constructions containing the IF2 directive, and some constructions with IFDEF or IFNDEF. If the /m option is enabled, Turbo Assembler will assemble this module correctly but will not optimize the code by removing NOPs, no matter how many passes are allowed. The warning "Module is pass dependent-compatibility pass was done" is displayed if this occurs. 2) Forward-referenced macros. The NOP-squishing capability also enhances the use of other TASM features, namely the JUMPS mode of operation. For example, jumps jnz foobar foobar: Under TASM 1.0, the JNZ generates 3 NOPs, because FOOBAR is forward-referenced. With the /m switch enabled in TASM 2.0, these NOPs are eliminated: The JUMPS mode can be enabled with no wasteful NOPs being generated. Usually, two passes are sufficient to squish out all NOPs. Occasionally, however, more passes may be required. If you need better compilation speed, place the correct overrides everywhere so that a single pass will produce optimal code. CALL Extensions --------------- The CALL instruction has been extended in Turbo Assembler to allow high-level language routines to be called in a language-independent manner. Any CALL instruction can now specify a language and an argument list for the routine being called. Turbo Assembler automatically generates the necessary stack setup and cleanup code required to pass the arguments to a high-level routine written in the specified language. The syntax is as follows: CALL <destination> <optional language>, <first argument>,<second argument>,... For example, call far ptr abc pascal, ax dx,word ptr wordval This example generates a far call to the Pascal-style routine ABC, which takes two arguments: a DWORD and a WORD. The DWORD argument is considered to be in AX and DX, and the WORD argument is assumed to be in WORDVAL. If the optional language is not specified, the current default language is assumed. Formerly, to call a higher-level language routine, the arguments needed to be explicitly PUSHed onto the stack, and the stack needed to be explicitly adjusted (after the call) depending on the language. The new CALL extensions save you the tedium of doing all this explicitly. PUSH, POP Instruction Extensions -------------------------------- The PUSH and POP instructions have been extended in Turbo Assembler to allow more than one argument to appear in a single PUSH or POP instruction. For example, push ax dx ;equivalent to PUSH AX then PUSH DX pop dx ax ;equivalent to POP DX then POP AX In addition, the PUSH instruction allows constant arguments even when generating code for the 8086 processor. Such instructions are replaced in the object code by a 10-byte sequence that simulates the 80186/286/386 PUSH immediate value instruction. COMM Extension -------------- The COMM directive has been extended to allow the array element size and the array element count to be selected independently of each other for FAR communal variables. This supports Turbo C++'s inline code generation, and can be used advantageously by a native assembly language programmer. The syntax is as follows: COMM FAR <id>{[<array element size multiplier>]}:<basic element size>{:<array count>} For example, this code fragment reserves an array of size 410: 10 elements each of size 41 bytes: COMM FAR ABC[41]:BYTE:10 Generalized Line-continuation Character --------------------------------------- In TASM 2.0, a line-continuation feature has been added that works in TASM's Ideal mode and is available even when the MASM 5.1 mode is off. A backslash (\) can be placed almost anywhere as a line-continuation character. It cannot be used to break up strings or identifiers. Its meaning is "read the next line in at this point and continue processing." It can thus be used in a natural way without losing the ability to comment each line as desired. For example, foo mystructure \ ;Start of structure fill. <0 \ ;Zero value is first. 1, \ ;One value. 2> ;Two value and end of structure. There are contexts where the line-continuation character is not recognized. In general, it isn't recognized in any context where characters are treated as text rather than identifiers, numbers, or strings, or in MASM mode when the line continuation is used in the first two symbols in the statement. For example, ifdif <123\>,<456\> does not recognize the two enclosed line-continuation characters. comment \ : begins a comment block, but does not define a near symbol called COMMENT. The line-continuation character is also not recognized inside of macro definitions. It is recognized, however, when the macro is expanded. Additional Display ------------------- TASM 2.0 displays the number of passes as well as the error and warning counts and remaining space. This allows you to assess the amount of work TASM is putting into the compilation process. Language-specific Procedures, Extrns, Publics, Calls ----------------------------------------------------- TASM 2.0 allows procedures, publics, extrns, and calls to be overridden with a language specifier. This causes wide flexibility in writing assembler code that interfaces with multiple language models. The MODEL statement has also been extended. Here are some syntax examples: <procname> PROC {<language modifier>} {<language>} {NEAR | FAR} {args and uses} EXTRN {<language>} <symbol>:<distance>, {<language>} <symbol>:<distance>,... PUBLIC {<language>} <symbol>, ... COMM {<language>} <symbol>:<distance>, ... GLOBAL {<language>} <symbol>:<distance>, ... PUBLICDLL {<language>} <symbol>, ... CALL <procname> {{<language>}, {args}} .MODEL {<model modifier>} <model> {<module name>} {, {<language modifier>} <language> {, <language modifier> } } Here's the syntax for the IDEAL mode PROC statement: PROC {<language modifier>} {<language>} <procname> {NEAR | FAR} {args and uses} Legal models are TINY, SMALL, MEDIUM, COMPACT, LARGE, and HUGE. Note that TPASCAL is also a legal model. Legal model modifiers are o FARSTACK (Selects model where SS is not assumed to be in DGROUP) o NEARSTACK (Selects model where SS is in DGROUP. This is the default) Legal languages are NOLANGUAGE, C, PASCAL, BASIC, FORTRAN, and PROLOG. Legal language modifiers are o NORMAL (Selects normal procedure entry/exit sequences) o WINDOWS (Selects MSWindows procedure entry/exit sequences) You don't need the .MODEL statement to make use of any of these language specifiers; the .MODEL statement simply serves to set the default language. New MODEL Identifiers: WINDOWS ------------------------------ Here is a description of the model modifier SS_NE_DS and the language modifiers NORMAL and WINDOWS. The model modifier can precede any use of a model keyword. This only happens in the .MODEL statement. For example, .MODEL SS_NE_DS LARGE ;Equivalent to TC's default large model This modifier causes SS to be assumed to NOTHING and the stack, if any, to not be part of DGROUP. The language modifiers can precede any use of a language keyword. A language keyword can be used in any of the following places: .MODEL, EXTRN, GLOBAL, PUBLIC, PUBLICDLL, COMM, PROC, CALL. A language modifier affects the type of stack frame that's generated for procedure entry and exit. When used in EXTRN, GLOBAL, PUBLIC, PUBLICDLL, COMM, and CALL, a language modifier is allowed but will have no effect. The stack frames actually generated for each modifier are as follows: NORMAL: ;No entry/exit sequence generated if no args or locals. ;8086 version (186 version uses ENTER/LEAVE). push bp mov bp,sp sub sp,local_size ;If any locals. <push uses registers> ... <pop uses registers> mov sp,bp ;If any locals. pop bp ret WINDOWS: push ds pop ax xchg ax,ax inc bp push bp mov bp,sp push ds mov ds,ax sub sp,local_size ;If any locals. <push uses registers> ... <pop uses registers> sub bp,2 ;If any locals. mov sp,bp ;If any locals. pop ds pop bp dec bp ret Here's an example: .MODEL large,windows pascal .code foo proc arg abc:word,def:word xor ax,ax ;Generates FAR WINDOWS PASCAL sequences. ret endp foo proc normal c arg ghi:word,jkl:word xor ax,ax ;Generates FAR NORMAL C sequences. ret endp VIRTUAL Segments ---------------- A new keyword VIRTUAL has been added to the SEGMENT statement. VIRTUAL defines a special kind of segment that will be treated as a common area and attached to another segment at link time. <segname> SEGMENT VIRTUAL ;In MASM mode. ... ENDS SEGMENT <segname> VIRTUAL ;In Ideal mode. ... ENDS In TASM, the VIRTUAL segment is assumed to be attached to the enclosing segment. The VIRTUAL segment also inherits its attributes from the enclosing segment. A VIRTUAL segment is treated as normal except that it is considered part of its parent segment for the purposes of ASSUMEs. The linker treats virtual segments as a common area that will be combined across modules. This permits static data that comes into many modules from include files to be shared. QASM Compatibility Additions ---------------------------- TASM 2.0 has new and modified directives to support source code for QASM: .STARTUP and STARTUPCODE These commands generate startup code for the particular model in effect at the time. These also define the near label @@Startup and cause the END statement at the end of the module to generate the equivalent of 'END @@Startup'. Note that only the 'STARTUPCODE' directive is available in IDEAL mode. .MODEL and MODEL It is now possible to select a third field in the .MODEL statement to specify the stack association with DGROUP: NEARSTACK or FARSTACK. For example, .MODEL SMALL,C,FARSTACK would specify that the stack not be included in DGROUP. This capability is already provided in TASM through the language modifiers of the same name. The additional field is provided only for MASM compatibility. Two new predefined variables have been added: Startup: Defined by the .STARTUP and STARTUPCODE directives. @Model: An integer representing the model currently in effect. 0 = TINY 1 = SMALL 2 = COMPACT 3 = MEDIUM 4 = LARGE 5 = HUGE 486 Instruction Support ----------------------- The following directives have been added to TASM 2.0 to support the Intel 486 microprocessor: .486,.486c (Masm mode only) P486N: Enables assembly of non-protected instructions for the 486 processor. .486p (Masm mode only) P486: Enables assembly of protected instructions for the 486 processor. BSWAP <32-bit register>: 486 byte swap instruction. XADD <r/m>,<reg>: 486 exchange and add instruction. CMPXCHG <r/m>,<reg>: 486 compare and exchange instruction. INVD: 486 invalidate data cache instruction. WBINVD: 486 write back and invalidate data cache inst. INVLPG <memptr>: 486 invalidate TLB entry for address inst. The following test registers have also been added: TR3,TR4,TR5 New TASM 2.0 Error Messages --------------------------- TASM 2.0 reports several new error messages: Global type doesn't match symbol type This warning is given when a symbol is declared using the GLOBAL statement and is also defined in the same module, but the type specified in the GLOBAL and the actual type of the symbol don't agree. Illegal segment address This error appears if an address greater than 65,535 is specified as a constant segment address; for example, FOO SEGMENT AT 12345h Module is pass-dependent--compatibility pass was done. This warning occurs if a pass-dependent construction was encountered and the /m command-line switch was specified. A MASM-compatible pass was done. Near jump or call to different CS This error occurs if the user attempts to perform a NEAR CALL or JMP to a symbol that's defined in an area where CS is assumed to a different segment. Only one startup sequence allowed This error appears if you have more than one .STARTUP or STARTUPCODE statement in a module. Smart code generation must be enabled Certain special features of code generation require SMART code generation to be enabled. These include PUSH of a pointer, POP of a pointer, and PUSH of a constant (8086 only). Text macro expansion exceeds maximum line length This error occurs when expansion of a text macro causes the maximum allowable line length to be exceeded. USES has no effect without language This warning appears if you specify a USES statement when no language is in effect. CODEPTR Type ------------ CODEPTR returns the default procedure address size depending on the current model (WORD for models with NEAR code; DWORD for models with FAR code). CODEPTR can be used wherever DATAPTR is used. Here is its syntax: CODEPTR expression RETCODE Instruction ------------------- The RETCODE instruction is exactly equivalent to RETN or RETF, depending on the specified model. RETCODE syntax follows: RETCODE {<expression>} RETCODE is available in both MASM and Ideal modes. SMART/NOSMART ------------- The SMART/NOSMART directives control the generation of optimized object code. These are the areas that the SMART and NOSMART directives apply to: 1) OR, AND, or XOR of a signed immediate byte 2) PUSH <constant> 3) PUSH <large pointer> POP <large pointer> 4) CALL <far address in same segment> 5) JMP <far address in same segment> 6) LEA <constant effective address> The default condition is SMART enabled. When SMART is enabled, a qualifying FAR jump will be replaced by a NEAR or a SHORT jump. Also, when SMART is enabled, a qualifying FAR call will be replaced by a PUSH CS instruction and a NEAR call. When NOSMART is selected, the following code generation changes occur: a) AND, OR, XOR of an immediate word value are no longer done using the signed-extended immediate byte version of these instructions where possible, but rather the longer immediate word version that MASM uses. b) PUSH of a constant value on the 8086 processor using the special 10-byte code sequence (which preserves all registers and flags) is not allowed. c) PUSH and POP of a DWORD memory variable (or PWORD variable on a 386) are not allowed. d) Far JMPs and CALLs within the same segment are no longer optimized by replacing the FAR JMP or CALL with the NEAR version. e) LEA instructions that refer to a constant effective address will no longer be converted to the equivalent MOV operations. For maximum MASM compatibility, you must select NOSMART and QUIRKS. Overlay Object Code ------------------- The /o commmand-line option Function Generates overlay code Syntax {/o} Remarks Turbo Assembler 2.0 supports overlays. Specifying the /o switch on the command line causes overlay-compatible fixups to be generated. When this switch is used, 386 references to USE32 segments should not be made since they won't link properly.