TILE-Gx Dependent Features
**************************

Options
=======

The following table lists all available TILE-Gx specific options:

-m32 | -m64
     Select the word size, either 32 bits or 64 bits.

-EB | -EL
     Select the endianness, either big-endian (-EB) or little-endian (-EL).

Syntax
======

Block comments are delimited by /* and */.  End of line comments may be introduced by #.

Instructions consist of a leading opcode or macro name followed by whitespace and an optional comma-separated list of operands:

     OPCODE [OPERAND, ...]

Instructions must be separated by a newline or semicolon.

There are two ways to write code: either write naked instructions, which the assembler is free to combine into VLIW bundles, or specify the VLIW bundles explicitly.

Bundles are specified using curly braces:

     { ADD r3,r4,r5 ; ADD r7,r8,r9 ; LW r10,r11 }

A bundle can span multiple lines. If you want to put multiple instructions on a line, whether in a bundle or not, you need to separate them with semicolons as in this example.

A bundle may contain one or more instructions, up to the limit specified by the ISA (currently three). If fewer instructions are specified than the hardware supports in a bundle, the assembler inserts fnop instructions automatically.

The assembler will prefer to preserve the ordering of instructions within the bundle, putting the first instruction in a lower-numbered pipeline than the next one, etc.  This fact, combined with the optional use of explicit fnop or nop instructions, allows precise control over which pipeline executes each instruction.

If the instructions cannot be bundled in the listed order, the assembler will automatically try to find a valid pipeline assignment. If there is no way to bundle the instructions together, the assembler reports an error.

The assembler does not yet auto-bundle (automatically combine multiple instructions into one bundle), but it reserves the right to do so in the future.  If you want to force an instruction to run by itself, put it in a bundle explicitly with curly braces and use nop instructions (not fnop) to fill the remaining pipeline slots in that bundle.

Opcode Names
------------

For a complete list of opcodes and descriptions of their semantics, see TILE-Gx Instruction Set Architecture, available upon request at www.tilera.com.

Register Names
--------------

General-purpose registers are represented by predefined symbols of the form rN, where N represents a number between 0 and 63.  However, the following registers have canonical names that must be used instead:

r54
     sp

r55
     lr

r56
     sn

r57
     idn0

r58
     idn1

r59
     udn0

r60
     udn1

r61
     udn2

r62
     udn3

r63
     zero

The assembler will emit a warning if a numeric name is used instead of the non-numeric name.  The .no_require_canonical_reg_names assembler pseudo-op turns off this warning. .require_canonical_reg_names turns it back on.

Symbolic Operand Modifiers
--------------------------

The assembler supports several modifiers when using symbol addresses in TILE-Gx instruction operands.  The general syntax is the following:

     modifier(symbol)

The following modifiers are supported:

hw0

     This modifier is used to load bits 0-15 of the symbol's address.

hw1

     This modifier is used to load bits 16-31 of the symbol's address.

hw2

     This modifier is used to load bits 32-47 of the symbol's address.

hw3

     This modifier is used to load bits 48-63 of the symbol's address.

hw0_last

     This modifier yields the same value as hw0, but it also checks that the value does not overflow.

hw1_last

     This modifier yields the same value as hw1, but it also checks that the value does not overflow.

hw2_last

     This modifier yields the same value as hw2, but it also checks that the value does not overflow.

     A 48-bit symbolic value is constructed by using the following idiom:

          moveli r0, hw2_last(sym)
          shl16insli r0, r0, hw1(sym)
          shl16insli r0, r0, hw0(sym)

hw0_got

     This modifier is used to load bits 0-15 of the symbol's offset in the GOT entry corresponding to the symbol.

hw0_last_got

     This modifier yields the same value as hw0_got, but it also checks that the value does not overflow.

hw1_last_got

     This modifier is used to load bits 16-31 of the symbol's offset in the GOT entry corresponding to the symbol, and it also checks that the value does not overflow.

plt

     This modifier is used for function symbols.  It causes a procedure linkage table, an array of code stubs, to be created at the time the shared object is created or linked against, together with a global offset table entry.  The value is a pc-relative offset to the corresponding stub code in the procedure linkage table.  This arrangement causes the run-time symbol resolver to be called to look up and set the value of the symbol the first time the function is called (at latest; depending environment variables).  It is only safe to leave the symbol unresolved this way if all references are function calls.

hw0_plt

     This modifier is used to load bits 0-15 of the pc-relative address of a plt entry.

hw1_plt

     This modifier is used to load bits 16-31 of the pc-relative address of a plt entry.

hw1_last_plt

     This modifier yields the same value as hw1_plt, but it also checks that the value does not overflow.

hw2_last_plt

     This modifier is used to load bits 32-47 of the pc-relative address of a plt entry, and it also checks that the value does not overflow.

hw0_tls_gd

     This modifier is used to load bits 0-15 of the offset of the GOT entry of the symbol's TLS descriptor, to be used for general-dynamic TLS accesses.

hw0_last_tls_gd

     This modifier yields the same value as hw0_tls_gd, but it also checks that the value does not overflow.

hw1_last_tls_gd

     This modifier is used to load bits 16-31 of the offset of the GOT entry of the symbol's TLS descriptor, to be used for general-dynamic TLS accesses.  It also checks that the value does not overflow.

hw0_tls_ie

     This modifier is used to load bits 0-15 of the offset of the GOT entry containing the offset of the symbol's address from the TCB, to be used for initial-exec TLS accesses.

hw0_last_tls_ie

     This modifier yields the same value as hw0_tls_ie, but it also checks that the value does not overflow.

hw1_last_tls_ie

     This modifier is used to load bits 16-31 of the offset of the GOT entry containing the offset of the symbol's address from the TCB, to be used for initial-exec TLS accesses.  It also checks that the value does not overflow.

hw0_tls_le

     This modifier is used to load bits 0-15 of the offset of the symbol's address from the TCB, to be used for local-exec TLS accesses.

hw0_last_tls_le

     This modifier yields the same value as hw0_tls_le, but it also checks that the value does not overflow.

hw1_last_tls_le

     This modifier is used to load bits 16-31 of the offset of the symbol's address from the TCB, to be used for local-exec TLS accesses.  It also checks that the value does not overflow.

tls_gd_call

     This modifier is used to tag an instruction as the ``call'' part of a calling sequence for a TLS GD reference of its operand.

tls_gd_add

     This modifier is used to tag an instruction as the ``add'' part of a calling sequence for a TLS GD reference of its operand.

tls_ie_load

     This modifier is used to tag an instruction as the ``load'' part of a calling sequence for a TLS IE reference of its operand.

TILE-Gx Directives
==================

.align EXPRESSION [, EXPRESSION]
     This is the generic .ALIGN directive.  The first argument is the requested alignment in bytes.

.allow_suspicious_bundles
     Turns on error checking for combinations of instructions in a bundle that probably indicate a programming error.  This is on by default.

.no_allow_suspicious_bundles
     Turns off error checking for combinations of instructions in a bundle that probably indicate a programming error.

.require_canonical_reg_names
     Require that canonical register names be used, and emit a warning if the numeric names are used.  This is on by default.

.no_require_canonical_reg_names
     Permit the use of numeric names for registers that have canonical names.