<html lang="en">
<head>
<title>CRIS-Symbols - Using as</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Using as">
<meta name="generator" content="makeinfo 4.13">
<link title="Top" rel="start" href="index.html#Top">
<link rel="up" href="CRIS_002dDependent.html#CRIS_002dDependent" title="CRIS-Dependent">
<link rel="prev" href="CRIS_002dExpand.html#CRIS_002dExpand" title="CRIS-Expand">
<link rel="next" href="CRIS_002dSyntax.html#CRIS_002dSyntax" title="CRIS-Syntax">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
<!--
This file documents the GNU Assembler "as".

Copyright (C) 1991-2019 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3
or any later version published by the Free Software Foundation;
with no Invariant Sections, with no Front-Cover Texts, and with no
Back-Cover Texts.  A copy of the license is included in the
section entitled ``GNU Free Documentation License''.

-->
<meta http-equiv="Content-Style-Type" content="text/css">
<style type="text/css"><!--
  pre.display { font-family:inherit }
  pre.format  { font-family:inherit }
  pre.smalldisplay { font-family:inherit; font-size:smaller }
  pre.smallformat  { font-family:inherit; font-size:smaller }
  pre.smallexample { font-size:smaller }
  pre.smalllisp    { font-size:smaller }
  span.sc    { font-variant:small-caps }
  span.roman { font-family:serif; font-weight:normal; } 
  span.sansserif { font-family:sans-serif; font-weight:normal; } 
--></style>
</head>
<body>
<div class="node">
<a name="CRIS-Symbols"></a>
<a name="CRIS_002dSymbols"></a>
<p>
Next:&nbsp;<a rel="next" accesskey="n" href="CRIS_002dSyntax.html#CRIS_002dSyntax">CRIS-Syntax</a>,
Previous:&nbsp;<a rel="previous" accesskey="p" href="CRIS_002dExpand.html#CRIS_002dExpand">CRIS-Expand</a>,
Up:&nbsp;<a rel="up" accesskey="u" href="CRIS_002dDependent.html#CRIS_002dDependent">CRIS-Dependent</a>
<hr>
</div>

<h4 class="subsection">9.9.3 Symbols</h4>

<p><a name="index-Symbols_002c-built_002din_002c-CRIS-905"></a><a name="index-Symbols_002c-CRIS_002c-built_002din-906"></a><a name="index-CRIS-built_002din-symbols-907"></a><a name="index-Built_002din-symbols_002c-CRIS-908"></a>
Some symbols are defined by the assembler.  They're intended to
be used in conditional assembly, for example:
<pre class="smallexample">      .if ..asm.arch.cris.v32
      <var>code for CRIS v32</var>
      .elseif ..asm.arch.cris.common_v10_v32
      <var>code common to CRIS v32 and CRIS v10</var>
      .elseif ..asm.arch.cris.v10 | ..asm.arch.cris.any_v0_v10
      <var>code for v10</var>
      .else
      .error "Code needs to be added here."
      .endif
</pre>
   <p>These symbols are defined in the assembler, reflecting
command-line options, either when specified or the default. 
They are always defined, to 0 or 1.
     <dl>
<dt><code>..asm.arch.cris.any_v0_v10</code><dd>This symbol is non-zero when <samp><span class="option">--march=v0_v10</span></samp> is specified
or the default.

     <br><dt><code>..asm.arch.cris.common_v10_v32</code><dd>Set according to the option <samp><span class="option">--march=common_v10_v32</span></samp>.

     <br><dt><code>..asm.arch.cris.v10</code><dd>Reflects the option <samp><span class="option">--march=v10</span></samp>.

     <br><dt><code>..asm.arch.cris.v32</code><dd>Corresponds to <samp><span class="option">--march=v10</span></samp>. 
</dl>

   <p>Speaking of symbols, when a symbol is used in code, it can have
a suffix modifying its value for use in position-independent
code. See <a href="CRIS_002dPic.html#CRIS_002dPic">CRIS-Pic</a>.

   </body></html>

