<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This file documents the GNU Assembler "as".

Copyright (C) 1991-2014 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".
 -->
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>Using as: GNU Assembler</title>

<meta name="description" content="Using as: GNU Assembler">
<meta name="keywords" content="Using as: GNU Assembler">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="AS-Index.html#AS-Index" rel="index" title="AS Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Overview.html#Overview" rel="up" title="Overview">
<link href="Object-Formats.html#Object-Formats" rel="next" title="Object Formats">
<link href="Manual.html#Manual" rel="prev" title="Manual">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>


</head>

<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="GNU-Assembler"></a>
<div class="header">
<p>
Next: <a href="Object-Formats.html#Object-Formats" accesskey="n" rel="next">Object Formats</a>, Previous: <a href="Manual.html#Manual" accesskey="p" rel="prev">Manual</a>, Up: <a href="Overview.html#Overview" accesskey="u" rel="up">Overview</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="AS-Index.html#AS-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="The-GNU-Assembler"></a>
<h3 class="section">1.2 The GNU Assembler</h3>


<p><small>GNU</small> <code>as</code> is really a family of assemblers.
If you use (or have used) the <small>GNU</small> assembler on one architecture, you
should find a fairly similar environment when you use it on another
architecture.  Each version has much in common with the others,
including object file formats, most assembler directives (often called
<em>pseudo-ops</em>) and assembler syntax.
</p>
<a name="index-purpose-of-GNU-assembler"></a>
<p><code>as</code> is primarily intended to assemble the output of the
<small>GNU</small> C compiler <code>gcc</code> for use by the linker
<code>ld</code>.  Nevertheless, we&rsquo;ve tried to make <code>as</code>
assemble correctly everything that other assemblers for the same
machine would assemble.
Any exceptions are documented explicitly (see <a href="Machine-Dependencies.html#Machine-Dependencies">Machine Dependencies</a>).
This doesn&rsquo;t mean <code>as</code> always uses the same syntax as another
assembler for the same architecture; for example, we know of several
incompatible versions of 680x0 assembly language syntax.
</p>

<p>Unlike older assemblers, <code>as</code> is designed to assemble a source
program in one pass of the source file.  This has a subtle impact on the
<kbd>.org</kbd> directive (see <a href="Org.html#Org"><code>.org</code></a>).
</p>



</body>
</html>
