[next] [tail] [up]

#### Intel syntax

Free Pascal supports Intel syntax for the Intel family of Ix86 processors in it’s asm blocks.

The Intel syntax in your asm block is converted to AT&T syntax by the compiler, after which it is inserted in the compiled source. The supported assembler constructs are a subset of the normal assembly syntax. In what follows we specify what constructs are not supported in Free Pascal, but which exist in Turbo Pascal:

- The TBYTE qualifier is not supported.
- The & identifier override is not supported.
- The HIGH operator is not supported.
- The LOW operator is not supported.
- The OFFSET and SEG operators are not supported. Use LEA and the various Lxx instructions instead.
- Expressions with constant strings are not allowed.
- Access to record fields via parenthesis is not allowed
- Typecasts with normal pascal types are not allowed, only recognized assembler typecasts are allowed. Example:

            mov al, byte ptr MyWord       -- allowed,
            mov al, byte(MyWord)          -- allowed,
            mov al, shortint(MyWord)      -- not allowed.

- Pascal type typecasts on constants are not allowed. Example:

            const s= 10; const t = 32767;

  in Turbo Pascal:

            mov al, byte(s)            -- useless typecast.
            mov al, byte(t)            -- syntax error!

  In this parser, either of those cases will give out a syntax error.
- Constant references expressions with constants only are not allowed (in all cases they do not work in protected mode, under L I N U X i386). Examples:

            mov al,byte ptr ['c']      -- not allowed.
            mov  al,byte ptr [100h]    -- not allowed.

  (This is due to the limitation of Turbo Assembler).
- Brackets within brackets are not allowed
- Expressions with segment overrides fully in brackets are presently not supported, but they can easily be implemented in BuildReference if requested. Example:

            mov al,[ds:bx]     -- not allowed

  use instead:

            mov al,ds:[bx]

- Possible allowed indexing are as follows:
  - Sreg:[REG+REG*SCALING+/-disp]
  - SReg:[REG+/-disp]
  - SReg:[REG]
  - SReg:[REG+REG+/-disp]
  - SReg:[REG+REG*SCALING]

  Where Sreg is optional and specifies the segment override. Notes:

  1. The order of terms is important contrary to Turbo Pascal.
  2. The Scaling value must be a value, and not an identifier to a symbol. Examples:

                   const myscale = 1;
                   ...
                   mov al,byte ptr [esi+ebx*myscale] -- not allowed.

     use:

                   mov al, byte ptr [esi+ebx*1]

- Possible variable identifier syntax is as follows: (Id = Variable or typed constant identifier.)
  1. ID
  2. [ID]
  3. [ID+expr]
  4. ID[expr]

  Possible fields are as follow:

  1. ID.subfield.subfield ...
  2. [ref].ID.subfield.subfield ...
  3. [ref].typename.subfield ...
- Local abels: Contrary to Turbo Pascal, local labels, must at least contain one character after the local symbol indicator. Example:

            @:                -- not allowed

  use instead, for example:

            @1:               -- allowed

- Contrary to Turbo Pascal local references cannot be used as references, only as displacements. Example:

            lds si,@mylabel   -- not allowed

- Contrary to Turbo Pascal, SEGCS, SEGDS, SEGES and SEGSS segment overrides are presently not supported. (This is a planned addition though).
- Contrary to Turbo Pascal where memory sizes specifiers can be practically anywhere, the Free Pascal Intel inline assembler requires memory size specifiers to be outside the brackets. Example:

            mov al,[byte ptr myvar]    -- not allowed.

  use:

            mov al,byte ptr [myvar]    -- allowed.

- Base and Index registers must be 32-bit registers. (limitation of the GNU Assembler).
- XLAT is equivalent to XLATB.
- Only Single and Double FPU opcodes are supported.
- Floating point opcodes are currently not supported (except those which involve only floating point registers).

The Intel inline assembler supports the following macros:

@Result
  represents the function result return value.
Self
  represents the object method pointer in methods.

[next] [front] [up]