diff options
Diffstat (limited to 'gas/doc/c-tic54x.texi')
| -rw-r--r-- | gas/doc/c-tic54x.texi | 767 |
1 files changed, 767 insertions, 0 deletions
diff --git a/gas/doc/c-tic54x.texi b/gas/doc/c-tic54x.texi new file mode 100644 index 0000000..eb8e453 --- /dev/null +++ b/gas/doc/c-tic54x.texi @@ -0,0 +1,767 @@ +@c Copyright (C) 1999, 2000 Free Software Foundation, Inc. +@c This is part of the GAS manual. +@c For copying conditions, see the file as.texinfo. +@c TI TMS320C54X description by Timothy Wall, twall@cygnus.com +@ifset GENERIC +@page +@node C54X-Dependent +@chapter C54X Dependent Features +@end ifset +@ifclear GENERIC +@node Machine Dependencies +@chapter C54X Dependent Features +@end ifclear + +@cindex C54X support +@menu +* C54X-Opts:: Command-line Options +* C54X-Block:: Blocking +* C54X-Env:: Environment Settings +* C54X-Constants:: Constants Syntax +* C54X-Subsyms:: String Substitution +* C54X-Locals:: Local Label Syntax +* C54X-Builtins:: Builtin Assembler Math Functions +* C54X-Ext:: Extended Addressing Support +* C54X-Directives:: Directives +* C54X-Macros:: Macro Features +* C54X-MMRegs:: Memory-mapped Registers +@end menu + +@node C54X-Opts +@section Options + +@cindex options, C54X +@cindex C54X options +The 'c54x version of @code{@value{AS}} has a few machine-dependent options. + +@cindex @samp{-mfar-mode} option, far-mode +@cindex @samp{-mf} option, far-mode +You can use the @samp{-mfar-mode} option to enable extended addressing mode. +All addresses will be assumed to be > 16 bits, and the appropriate +relocation types will be used. This option is equivalent to using the +@samp{.far_mode} directive in the assembly code. If you do not use the +@samp{-mfar-mode} option, all references will be assumed to be 16 bits. +This option may be abbreviated to @samp{-mf}. + +@cindex @samp{-mcpu} option, cpu +You can use the @samp{-mcpu} option to specify a particular CPU. +This option is equivalent to using the @samp{.version} directive in the +assembly code. For recognized CPU codes, see +@xref{C54X-Directives,,@code{.version}}. The default CPU version is +@samp{542}. + +@cindex @samp{-merrors-to-file} option, stderr redirect +@cindex @samp{-me} option, stderr redirect +You can use the @samp{-merrors-to-file} option to redirect error output +to a file (this provided for those deficient environments which don't +provide adequate output redirection). This option may be abbreviated to +@samp{-me}. + +@node C54X-Block +@section Blocking +A blocked section or memory block is guaranteed not to cross the blocking +boundary (usually a page, or 128 words) if it is smaller than the +blocking size, or to start on a page boundary if it is larger than the +blocking size. + +@node C54X-Env +@section Environment Settings + +@cindex environment settings, C54X +@cindex @samp{A_DIR} environment variable, C54X +@cindex @samp{C54XDSP_DIR} environment variable, C54X +@samp{C54XDSP_DIR} and @samp{A_DIR} are semicolon-separated +paths which are added to the list of directories normally searched for +source and include files. @samp{C54XDSP_DIR} will override @samp{A_DIR}. + +@node C54X-Constants +@section Constants Syntax + +@cindex constants, C54X +The C54X version of @code{@value{AS}} allows the following additional +constant formats, using a suffix to indicate the radix: +@smallexample +@cindex binary constants, C54X + +Binary @code{000000B, 011000b} +Octal @code{10Q, 224q} +Hexadecimal @code{45h, 0FH} + +@end smallexample + +@node C54X-Subsyms +@section String Substitution +A subset of allowable symbols (which we'll call subsyms) may be assigned +arbitrary string values. This is roughly equivalent to C preprocessor +#define macros. When @code{@value{AS}} encounters one of these +symbols, the symbol is replaced in the input stream by its string value. +Subsym names @strong{must} begin with a letter. + +Subsyms may be defined using the @code{.asg} and @code{.eval} directives +(@xref{C54X-Directives,,@code{.asg}}, +@xref{C54X-Directives,,@code{.eval}}. + +Expansion is recursive until a previously encountered symbol is seen, at +which point substitution stops. + +In this example, x is replaced with SYM2; SYM2 is replaced with SYM1, and SYM1 +is replaced with x. At this point, x has already been encountered +and the substitution stops. + +@smallexample @code + .asg "x",SYM1 + .asg "SYM1",SYM2 + .asg "SYM2",x + add x,a ; final code assembled is "add x, a" +@end smallexample + +Macro parameters are converted to subsyms; a side effect of this is the normal +@code{@value{AS}} '\ARG' dereferencing syntax is unnecessary. Subsyms +defined within a macro will have global scope, unless the @code{.var} +directive is used to identify the subsym as a local macro variable +@pxref{C54X-Directives,,@code{.var}}. + +Substitution may be forced in situations where replacement might be +ambiguous by placing colons on either side of the subsym. The following +code: + +@smallexample @code + .eval "10",x +LAB:X: add #x, a +@end smallexample + +When assembled becomes: + +@smallexample @code +LAB10 add #10, a +@end smallexample + +Smaller parts of the string assigned to a subsym may be accessed with +the following syntax: + +@table @code +@item @code{:@var{symbol}(@var{char_index}):} +Evaluates to a single-character string, the character at @var{char_index}. +@item @code{:@var{symbol}(@var{start},@var{length}):} +Evaluates to a substring of @var{symbol} beginning at @var{start} with +length @var{length}. +@end table + +@node C54X-Locals +@section Local Labels +Local labels may be defined in two ways: + +@itemize @bullet +@item +$N, where N is a decimal number between 0 and 9 +@item +LABEL?, where LABEL is any legal symbol name. +@end itemize + +Local labels thus defined may be redefined or automatically generated. +The scope of a local label is based on when it may be undefined or reset. +This happens when one of the following situations is encountered: + +@itemize @bullet +@item +.newblock directive @pxref{C54X-Directives,,@code{.newblock}} +@item +The current section is changed (.sect, .text, or .data) +@item +Entering or leaving an included file +@item +The macro scope where the label was defined is exited +@end itemize + +@node C54X-Builtins +@section Math Builtins + +@cindex math builtins, C54X +@cindex C54X builtin math functions +@cindex builtin math functions, C54X + +The following built-in functions may be used to generate a +floating-point value. All return a floating-point value except +@samp{$cvi}, @samp{$int}, and @samp{$sgn}, which return an integer +value. + +@table @code +@cindex @code{$acos} math builtin, C54X +@item @code{$acos(@var{expr})} +Returns the floating point arccosine of @var{expr}. + +@cindex @code{$asin} math builtin, C54X +@item @code{$asin(@var{expr})} +Returns the floating point arcsine of @var{expr}. + +@cindex @code{$atan} math builtin, C54X +@item @code{$atan(@var{expr})} +Returns the floating point arctangent of @var{expr}. + +@cindex @code{$atan2} math builtin, C54X +@item @code{$atan2(@var{expr1},@var{expr2})} +Returns the floating point arctangent of @var{expr1} / @var{expr2}. + +@cindex @code{$ceil} math builtin, C54X +@item @code{$ceil(@var{expr})} +Returns the smallest integer not less than @var{expr} as floating point. + +@cindex @code{$cosh} math builtin, C54X +@item @code{$cosh(@var{expr})} +Returns the floating point hyperbolic cosine of @var{expr}. + +@cindex @code{$cos} math builtin, C54X +@item @code{$cos(@var{expr})} +Returns the floating point cosine of @var{expr}. + +@cindex @code{$cvf} math builtin, C54X +@item @code{$cvf(@var{expr})} +Returns the integer value @var{expr} converted to floating-point. + +@cindex @code{$cvi} math builtin, C54X +@item @code{$cvi(@var{expr})} +Returns the floating point value @var{expr} converted to integer. + +@cindex @code{$exp} math builtin, C54X +@item @code{$exp(@var{expr})} +Returns the floating point value e ^ @var{expr}. + +@cindex @code{$fabs} math builtin, C54X +@item @code{$fabs(@var{expr})} +Returns the floating point absolute value of @var{expr}. + +@cindex @code{$floor} math builtin, C54X +@item @code{$floor(@var{expr})} +Returns the largest integer that is not greater than @var{expr} as +floating point. + +@cindex @code{$fmod} math builtin, C54X +@item @code{$fmod(@var{expr1},@var{expr2})} +Returns the floating point remainder of @var{expr1} / @var{expr2}. + +@cindex @code{$int} math builtin, C54X +@item @code{$int(@var{expr})} +Returns 1 if @var{expr} evaluates to an integer, zero otherwise. + +@cindex @code{$ldexp} math builtin, C54X +@item @code{$ldexp(@var{expr1},@var{expr2})} +Returns the floating point value @var{expr1} * 2 ^ @var{expr2}. + +@cindex @code{$log10} math builtin, C54X +@item @code{$log10(@var{expr})} +Returns the base 10 logarithm of @var{expr}. + +@cindex @code{$log} math builtin, C54X +@item @code{$log(@var{expr})} +Returns the natural logarithm of @var{expr}. + +@cindex @code{$max} math builtin, C54X +@item @code{$max(@var{expr1},@var{expr2})} +Returns the floating point maximum of @var{expr1} and @var{expr2}. + +@cindex @code{$min} math builtin, C54X +@item @code{$min(@var{expr1},@var{expr2})} +Returns the floating point minimum of @var{expr1} and @var{expr2}. + +@cindex @code{$pow} math builtin, C54X +@item @code{$pow(@var{expr1},@var{expr2})} +Returns the floating point value @var{expr1} ^ @var{expr2}. + +@cindex @code{$round} math builtin, C54X +@item @code{$round(@var{expr})} +Returns the nearest integer to @var{expr} as a floating point number. + +@cindex @code{$sgn} math builtin, C54X +@item @code{$sgn(@var{expr})} +Returns -1, 0, or 1 based on the sign of @var{expr}. + +@cindex @code{$sin} math builtin, C54X +@item @code{$sin(@var{expr})} +Returns the floating point sine of @var{expr}. + +@cindex @code{$sinh} math builtin, C54X +@item @code{$sinh(@var{expr})} +Returns the floating point hyperbolic sine of @var{expr}. + +@cindex @code{$sqrt} math builtin, C54X +@item @code{$sqrt(@var{expr})} +Returns the floating point square root of @var{expr}. + +@cindex @code{$tan} math builtin, C54X +@item @code{$tan(@var{expr})} +Returns the floating point tangent of @var{expr}. + +@cindex @code{$tanh} math builtin, C54X +@item @code{$tanh(@var{expr})} +Returns the floating point hyperbolic tangent of @var{expr}. + +@cindex @code{$trunc} math builtin, C54X +@item @code{$trunc(@var{expr})} +Returns the integer value of @var{expr} truncated towards zero as +floating point. + +@end table + +@node C54X-Ext +@section Extended Addressing +The @code{LDX} pseudo-op is provided for loading the extended addressing bits +of a label or address. For example, if an address @code{_label} resides +in extended program memory, the value of @code{_label} may be loaded as +follows: +@smallexample @code + ldx #_label,16,a ; loads extended bits of _label + or #_label,a ; loads lower 16 bits of _label + bacc a ; full address is in accumulator A +@end smallexample + +@node C54X-Directives +@section Directives + +@cindex machine directives, C54X +@cindex C54X machine directives + +@table @code + +@cindex @code{align} directive, C54X +@cindex @code{even} directive, C54X +@item .align [@var{size}] +@itemx .even +Align the section program counter on the next boundary, based on +@var{size}. @var{size} may be any power of 2. @code{.even} is +equivalent to @code{.align} with a @var{size} of 2. +@table @code +@item 1 +Align SPC to word boundary +@item 2 +Align SPC to longword boundary (same as .even) +@item 128 +Align SPC to page boundary +@end table + +@cindex @code{asg} directive, C54X +@item .asg @var{string}, @var{name} +Assign @var{name} the string @var{string}. String replacement is +performed on @var{string} before assignment. + +@cindex @code{eval} directive, C54X +@itemx .eval @var{string}, @var{name} +Evaluate the contents of string @var{string} and assign the result as a +string to the subsym @var{name}. String replacement is performed on +@var{string} before assignment. + +@cindex @code{bss} directive, C54X +@item .bss @var{symbol}, @var{size} [, [@var{blocking_flag}] [,@var{alignment_flag}]] +Reserve space for @var{symbol} in the .bss section. @var{size} is in +words. If present, @var{blocking_flag} indicates the allocated space +should be aligned on a page boundary if it would otherwise cross a page +boundary. If present, @var{alignment_flag} causes the assembler to +allocate @var{size} on a long word boundary. + +@cindex @code{byte} directive, C54X +@cindex @code{ubyte} directive, C54X +@cindex @code{char} directive, C54X +@cindex @code{uchar} directive, C54X +@item .byte @var{value} [,...,@var{value_n}] +@itemx .ubyte @var{value} [,...,@var{value_n}] +@itemx .char @var{value} [,...,@var{value_n}] +@itemx .uchar @var{value} [,...,@var{value_n}] +Place one or more bytes into consecutive words of the current section. +The upper 8 bits of each word is zero-filled. If a label is used, it +points to the word allocated for the first byte encountered. + +@cindex @code{clink} directive, C54X +@item .clink ["@var{section_name}"] +Set STYP_CLINK flag for this section, which indicates to the linker that +if no symbols from this section are referenced, the section should not +be included in the link. If @var{section_name} is omitted, the current +section is used. + +@cindex @code{c_mode} directive, C54X +@item .c_mode +TBD. + +@cindex @code{copy} directive, C54X +@item .copy "@var{filename}" | @var{filename} +@itemx .include "@var{filename}" | @var{filename} +Read source statements from @var{filename}. The normal include search +path is used. Normally .copy will cause statements from the included +file to be printed in the assembly listing and .include will not, but +this distinction is not currently implemented. + +@cindex @code{data} directive, C54X +@item .data +Begin assembling code into the .data section. + +@cindex @code{double} directive, C54X +@cindex @code{ldouble} directive, C54X +@cindex @code{float} directive, C54X +@cindex @code{xfloat} directive, C54X +@item .double @var{value} [,...,@var{value_n}] +@itemx .ldouble @var{value} [,...,@var{value_n}] +@itemx .float @var{value} [,...,@var{value_n}] +@itemx .xfloat @var{value} [,...,@var{value_n}] +Place an IEEE single-precision floating-point representation of one or +more floating-point values into the current section. All but +@code{.xfloat} align the result on a longword boundary. Values are +stored most-significant word first. + +@cindex @code{drlist} directive, C54X +@cindex @code{drnolist} directive, C54X +@item .drlist +@itemx .drnolist +Control printing of directives to the listing file. Ignored. + +@cindex @code{emsg} directive, C54X +@cindex @code{mmsg} directive, C54X +@cindex @code{wmsg} directive, C54X +@item .emsg @var{string} +@itemx .mmsg @var{string} +@itemx .wmsg @var{string} +Emit a user-defined error, message, or warning, respectively. + +@cindex @code{far_mode} directive, C54X +@item .far_mode +Use extended addressing when assembling statements. This should appear +only once per file, and is equivalent to the -mfar-mode option @pxref{C54X-Opts,,@code{-mfar-mode}}. + +@cindex @code{fclist} directive, C54X +@cindex @code{fcnolist} directive, C54X +@item .fclist +@itemx .fcnolist +Control printing of false conditional blocks to the listing file. + +@cindex @code{field} directive, C54X +@item .field @var{value} [,@var{size}] +Initialize a bitfield of @var{size} bits in the current section. If +@var{value} is relocatable, then @var{size} must be 16. @var{size} +defaults to 16 bits. If @var{value} does not fit into @var{size} bits, +the value will be truncated. Successive @code{.field} directives will +pack starting at the current word, filling the most significant bits +first, and aligning to the start of the next word if the field size does +not fit into the space remaining in the current word. A @code{.align} +directive with an operand of 1 will force the next @code{.field} +directive to begin packing into a new word. If a label is used, it +points to the word that contains the specified field. + +@cindex @code{global} directive, C54X +@cindex @code{def} directive, C54X +@cindex @code{ref} directive, C54X +@item .global @var{symbol} [,...,@var{symbol_n}] +@itemx .def @var{symbol} [,...,@var{symbol_n}] +@itemx .ref @var{symbol} [,...,@var{symbol_n}] +@code{.def} nominally identifies a symbol defined in the current file +and availalbe to other files. @code{.ref} identifies a symbol used in +the current file but defined elsewhere. Both map to the standard +@code{.global} directive. + +@cindex @code{half} directive, C54X +@cindex @code{uhalf} directive, C54X +@cindex @code{short} directive, C54X +@cindex @code{ushort} directive, C54X +@cindex @code{int} directive, C54X +@cindex @code{uint} directive, C54X +@cindex @code{word} directive, C54X +@cindex @code{uword} directive, C54X +@item .half @var{value} [,...,@var{value_n}] +@itemx .uhalf @var{value} [,...,@var{value_n}] +@itemx .short @var{value} [,...,@var{value_n}] +@itemx .ushort @var{value} [,...,@var{value_n}] +@itemx .int @var{value} [,...,@var{value_n}] +@itemx .uint @var{value} [,...,@var{value_n}] +@itemx .word @var{value} [,...,@var{value_n}] +@itemx .uword @var{value} [,...,@var{value_n}] +Place one or more values into consecutive words of the current section. +If a label is used, it points to the word allocated for the first value +encountered. + +@cindex @code{label} directive, C54X +@item .label @var{symbol} +Define a special @var{symbol} to refer to the load time address of the +current section program counter. + +@cindex @code{length} directive, C54X +@cindex @code{width} directive, C54X +@item .length +@itemx .width +Set the page length and width of the output listing file. Ignored. + +@cindex @code{list} directive, C54X +@cindex @code{nolist} directive, C54X +@item .list +@itemx .nolist +Control whether the source listing is printed. Ignored. + +@cindex @code{long} directive, C54X +@cindex @code{ulong} directive, C54X +@cindex @code{xlong} directive, C54X +@item .long @var{value} [,...,@var{value_n}] +@itemx .ulong @var{value} [,...,@var{value_n}] +@itemx .xlong @var{value} [,...,@var{value_n}] +Place one or more 32-bit values into consecutive words in the current +section. The most significant word is stored first. @code{.long} and +@code{.ulong} align the result on a longword boundary; @code{xlong} does +not. + +@cindex @code{loop} directive, C54X +@cindex @code{break} directive, C54X +@cindex @code{endloop} directive, C54X +@item .loop [@var{count}] +@itemx .break [@var{condition}] +@itemx .endloop +Repeatedly assemble a block of code. @code{.loop} begins the block, and +@code{.endloop} marks its termination. @var{count} defaults to 1024, +and indicates the number of times the block should be repeated. +@code{.break} terminates the loop so that assembly begins after the +@code{.endloop} directive. The optional @var{condition} will cause the +loop to terminate only if it evaluates to zero. + +@cindex @code{macro} directive, C54X +@cindex @code{endm} directive, C54X +@item @var{macro_name} .macro [@var{param1}][,...@var{param_n}] +@itemx [.mexit] +@itemx .endm +See the section on macros for more explanation (@xref{C54X-Macros}. + +@cindex @code{mlib} directive, C54X +@item .mlib "@var{filename}" | @var{filename} +Load the macro library @var{filename}. @var{filename} must be an +archived library (BFD ar-compatible) of text files, expected to contain +only macro definitions. The standard include search path is used. + +@cindex @code{mlist} directive, C54X +@cindex @code{mnolist} directive, C54X +@item .mlist +@item .mnolist +Control whether to include macro and loop block expansions in the +listing output. Ignored. + +@cindex @code{mmregs} directive, C54X +@item .mmregs +Define global symbolic names for the 'c54x registers. Supposedly +equivalent to executing @code{.set} directives for each register with +its memory-mapped value, but in reality is provided only for +compatibility and does nothing. + +@cindex @code{newblock} directive, C54X +@item .newblock +This directive resets any C54X local labels currently defined. Normal +@code{@value{AS}} local labels are unaffected. + +@cindex @code{option} directive, C54X +@item .option @var{option_list} +Set listing options. Ignored. + +@cindex @code{sblock} directive, C54X +@item .sblock "@var{section_name}" | @var{section_name} [,"@var{name_n}" | @var{name_n}] +Designate @var{section_name} for blocking. Blocking guarantees that a +section will start on a page boundary (128 words) if it would otherwise +cross a page boundary. Only initialized sections may be designated with +this directive. See also @xref{C54X-Block}. + +@cindex @code{sect} directive, C54X +@item .sect "@var{section_name}" +Define a named initialized section and make it the current section. + +@cindex @code{set} directive, C54X +@cindex @code{equ} directive, C54X +@item @var{symbol} .set "@var{value}" +@itemx @var{symbol} .equ "@var{value}" +Equate a constant @var{value} to a @var{symbol}, which is placed in the +symbol table. @var{symbol} may not be previously defined. + +@cindex @code{space} directive, C54X +@cindex @code{bes} directive, C54X +@item .space @var{size_in_bits} +@itemx .bes @var{size_in_bits} +Reserve the given number of bits in the current section and zero-fill +them. If a label is used with @code{.space}, it points to the +@strong{first} word reserved. With @code{.bes}, the label points to the +@strong{last} word reserved. + +@cindex @code{sslist} directive, C54X +@cindex @code{ssnolist} directive, C54X +@item .sslist +@itemx .ssnolist +Controls the inclusion of subsym replacement in the listing output. Ignored. + +@cindex @code{string} directive, C54X +@cindex @code{pstring} directive, C54X +@item .string "@var{string}" [,...,"@var{string_n}"] +@itemx .pstring "@var{string}" [,...,"@var{string_n}"] +Place 8-bit characters from @var{string} into the current section. +@code{.string} zero-fills the upper 8 bits of each word, while +@code{.pstring} puts two characters into each word, filling the +most-significant bits first. Unused space is zero-filled. If a label +is used, it points to the first word initialized. + +@cindex @code{struct} directive, C54X +@cindex @code{tag} directive, C54X +@cindex @code{endstruct} directive, C54X +@item [@var{stag}] .struct [@var{offset}] +@itemx [@var{name_1}] element [@var{count_1}] +@itemx [@var{name_2}] element [@var{count_2}] +@itemx [@var{tname}] .tag @var{stagx} [@var{tcount}] +@itemx ... +@itemx [@var{name_n}] element [@var{count_n}] +@itemx [@var{ssize}] .endstruct +@itemx @var{label} .tag [@var{stag}] +Assign symbolic offsets to the elements of a structure. @var{stag} +defines a symbol to use to reference the structure. @var{offset} +indicates a starting value to use for the first element encountered; +otherwise it defaults to zero. Each element can have a named offset, +@var{name}, which is a symbol assigned the value of the element's offset +into the structure. If @var{stag} is missing, these become global +symbols. @var{count} adjusts the offset that many times, as if +@code{element} were an array. @code{element} may be one of +@code{.byte}, @code{.word}, @code{.long}, @code{.float}, or any +equivalent of those, and the structure offset is adjusted accordingly. +@code{.field} and @code{.string} are also allowed; the size of +@code{.field} is one bit, and @code{.string} is considered to be one +word in size. Only element descriptors, structure/union tags, +@code{.align} and conditioanl assembly directies are allowed within +@code{.struct}/@code{.endstruct}. @code{.align} aligns member offsets +to word boundaries only. @var{ssize}, if provided, will always be +assigned the size of the structure. + +The @code{.tag} directive, in addition to being used to define a +structure/union element within a structure, may be used to apply a +structure to a symbol. Once applied to @var{label}, the individual +structure elements may be applied to @var{label} to produce the desired +offsets using @var{label} as the structure base. + +@cindex @code{tab} directive, C54X +@item .tab +Set the tab size in the output listing. Ignored. + +@cindex @code{union} directive, C54X +@cindex @code{tag} directive, C54X +@cindex @code{endunion} directive, C54X +@item [@var{utag}] .union +@itemx [@var{name_1}] element [@var{count_1}] +@itemx [@var{name_2}] element [@var{count_2}] +@itemx [@var{tname}] .tag @var{utagx}[,@var{tcount}] +@itemx ... +@itemx [@var{name_n}] element [@var{count_n}] +@itemx [@var{usize}] .endstruct +@itemx @var{label} .tag [@var{utag}] +Similar to @code{.struct}, but the offset after each element is reset to +zero, and the @var{usize} is set to the maximum of all defined elements. +Starting offset for the union is always zero. + +@cindex @code{usect} directive, C54X +@item [@var{symbol}] .usect "@var{section_name}", @var{size}, [,[@var{blocking_flag}] [,@var{alignment_flag}]] +Reserve space for variables in a named, uninitialzed section (similar to +.bss). @code{.usect} allows definitions sections independent of .bss. +@var{symbol} points to the first location reserved by this allocation. +The symbol may be used as a variable name. @var{size} is the allocated +size in words. @var{blocking_flag} indicates whether to block this +section on a page boundary (128 words) (@pxref{C54X-Block}). +@var{alignment flag} indicates whether the section should be +longword-aligned. + +@cindex @code{var} directive, C54X +@item .var @var{sym}[,..., @var{sym_n}] +Define a subsym to be a local variable within a macro. See +@xref{C54X-Macros}. + +@cindex @code{version} directive, C54X +@item .version @var{version} +Set which processor to build instructions for. Though the following +values are accepted, the op is ignored. +@table @code +@item 541 +@itemx 542 +@itemx 543 +@itemx 545 +@itemx 545LP +@itemx 546LP +@itemx 548 +@itemx 549 +@end table +@end table + +@node C54X-Macros +@section Macros + +@cindex C54X-specific macros +@cindex macros, C54X +Macros do not require explicit dereferencing of arguments (i.e. \ARG). + +During macro expansion, the macro parameters are converted to subsyms. +If the number of arguments passed the macro invocation exceeds the +number of parameters defined, the last parameter is assigned the string +equivalent of all remaining arguments. If fewer arguments are given +than parameters, the missing parameters are assigned empty strings. To +include a comma in an argument, you must enclose the agument in quotes. + +@cindex subsym builtins, C54X +@cindex C54X subsym builtins +@cindex builtin subsym functions, C54X +The following built-in subsym functions allow examination of the string +value of subsyms (or ordinary strings). The arguments are strings +unless otherwise indicated (subsyms passed as args will be replaced by +the strings they represent). +@table @code +@cindex @code{$symlen} subsym builtin, C54X +@item @code{$symlen(@var{str})} +Returns the length of @var{str}. + +@cindex @code{$symcmp} subsym builtin, C54X +@item @code{$symcmp(@var{str1},@var{str2})} +Returns 0 if @var{str1} == @var{str2}, non-zero otherwise. + +@cindex @code{$firstch} subsym builtin, C54X +@item @code{$firstch(@var{str},@var{ch})} +Returns index of the first occurrence of character constant @var{ch} in +@var{str}. + +@cindex @code{$lastch} subsym builtin, C54X +@item @code{$lastch(@var{str},@var{ch})} +Returns index of the last occurrence of character constant @var{ch} in +@var{str}. + +@cindex @code{$isdefed} subsym builtin, C54X +@item @code{$isdefed(@var{symbol})} +Returns zero if the symbol @var{symbol} is not in the symbol table, +non-zero otherwise. + +@cindex @code{$ismember} subsym builtin, C54X +@item @code{$ismember(@var{symbol},@var{list})} +Assign the first member of comma-separated string @var{list} to +@var{symbol}; @var{list} is reassigned the remainder of the list. Returns +zero if @var{list} is a null string. Both arguments must be subsyms. + +@cindex @code{$iscons} subsym builtin, C54X +@item @code{$iscons(@var{expr})} +Returns 1 if string @var{expr} is binary, 2 if octal, 3 if hexadecimal, +4 if a character, 5 if decimal, and zero if not an integer. + +@cindex @code{$isname} subsym builtin, C54X +@item @code{$isname(@var{name})} +Returns 1 if @var{name} is a valid symbol name, zero otherwise. + +@cindex @code{$isreg} subsym builtin, C54X +@item @code{$isreg(@var{reg})} +Returns 1 if @var{reg} is a valid predefined register name (AR0-AR7 only). + +@cindex @code{$structsz} subsym builtin, C54X +@item @code{$structsz(@var{stag})} +Returns the size of the structure or union represented by @var{stag}. + +@cindex @code{$structacc} subsym builtin, C54X +@item @code{$structacc(@var{stag})} +Returns the reference point of the structure or union represented by +@var{stag}. Always returns zero. + +@end table + +@node C54X-MMRegs +@section Memory-mapped Registers + +@cindex C54X memory-mapped registers +@cindex registers, C54X memory-mapped +@cindex memory-mapped registers, C54X +The following symbols are recognized as memory-mapped registers: + +@table @code +@end table
\ No newline at end of file |