<html lang="en">
<head>
<title>V850 Options - 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="V850_002dDependent.html#V850_002dDependent" title="V850-Dependent">
<link rel="next" href="V850-Syntax.html#V850-Syntax" title="V850 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, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
2000, 2001, 2002, 2006, 2007, 2008, 2009, 2010 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>
<link rel="stylesheet" type="text/css" href="../cs.css">
</head>
<body>
<div class="node">
<a name="V850-Options"></a>
<p>
Next:&nbsp;<a rel="next" accesskey="n" href="V850-Syntax.html#V850-Syntax">V850 Syntax</a>,
Up:&nbsp;<a rel="up" accesskey="u" href="V850_002dDependent.html#V850_002dDependent">V850-Dependent</a>
<hr>
</div>

<h4 class="subsection">9.41.1 Options</h4>

<p><a name="index-V850-options-_0028none_0029-1940"></a><a name="index-options-for-V850-_0028none_0029-1941"></a><code>as</code> supports the following additional command-line options
for the V850 processor family:

   <p><a name="index-command-line-options_002c-V850-1942"></a><a name="index-V850-command-line-options-1943"></a>
     
<a name="index-g_t_0040code_007b_002dwsigned_005foverflow_007d-command-line-option_002c-V850-1944"></a>
<dl><dt><code>-wsigned_overflow</code><dd>Causes warnings to be produced when signed immediate values overflow the
space available for then within their opcodes.  By default this option
is disabled as it is possible to receive spurious warnings due to using
exact bit patterns as immediate constants.

     <p><a name="index-g_t_0040code_007b_002dwunsigned_005foverflow_007d-command-line-option_002c-V850-1945"></a><br><dt><code>-wunsigned_overflow</code><dd>Causes warnings to be produced when unsigned immediate values overflow
the space available for then within their opcodes.  By default this
option is disabled as it is possible to receive spurious warnings due to
using exact bit patterns as immediate constants.

     <p><a name="index-g_t_0040code_007b_002dmv850_007d-command-line-option_002c-V850-1946"></a><br><dt><code>-mv850</code><dd>Specifies that the assembled code should be marked as being targeted at
the V850 processor.  This allows the linker to detect attempts to link
such code with code assembled for other processors.

     <p><a name="index-g_t_0040code_007b_002dmv850e_007d-command-line-option_002c-V850-1947"></a><br><dt><code>-mv850e</code><dd>Specifies that the assembled code should be marked as being targeted at
the V850E processor.  This allows the linker to detect attempts to link
such code with code assembled for other processors.

     <p><a name="index-g_t_0040code_007b_002dmv850e1_007d-command-line-option_002c-V850-1948"></a><br><dt><code>-mv850e1</code><dd>Specifies that the assembled code should be marked as being targeted at
the V850E1 processor.  This allows the linker to detect attempts to link
such code with code assembled for other processors.

     <p><a name="index-g_t_0040code_007b_002dmv850any_007d-command-line-option_002c-V850-1949"></a><br><dt><code>-mv850any</code><dd>Specifies that the assembled code should be marked as being targeted at
the V850 processor but support instructions that are specific to the
extended variants of the process.  This allows the production of
binaries that contain target specific code, but which are also intended
to be used in a generic fashion.  For example libgcc.a contains generic
routines used by the code produced by GCC for all versions of the v850
architecture, together with support routines only used by the V850E
architecture.

     <p><a name="index-g_t_0040code_007b_002dmv850e2_007d-command-line-option_002c-V850-1950"></a><br><dt><code>-mv850e2</code><dd>Specifies that the assembled code should be marked as being targeted at
the V850E2 processor.  This allows the linker to detect attempts to link
such code with code assembled for other processors.

     <p><a name="index-g_t_0040code_007b_002dmv850e2v3_007d-command-line-option_002c-V850-1951"></a><br><dt><code>-mv850e2v3</code><dd>Specifies that the assembled code should be marked as being targeted at
the V850E2V3 processor.  This allows the linker to detect attempts to link
such code with code assembled for other processors.

     <p><a name="index-g_t_0040code_007b_002dmrelax_007d-command-line-option_002c-V850-1952"></a><br><dt><code>-mrelax</code><dd>Enables relaxation.  This allows the .longcall and .longjump pseudo
ops to be used in the assembler source code.  These ops label sections
of code which are either a long function call or a long branch.  The
assembler will then flag these sections of code and the linker will
attempt to relax them.

   </dl>

   </body></html>

