<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>An Example — llvmpy tag: 0.12.0 documentation</title>
<link rel="stylesheet" href="../_static/default.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: 'tag: 0.12.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="top" title="llvmpy tag: 0.12.0 documentation" href="../index.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li><a href="../index.html">llvmpy tag: 0.12.0 documentation</a> »</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<table border="1" class="docutils">
<colgroup>
<col width="100%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td>layout: page</td>
</tr>
<tr class="row-even"><td>title: Types</td>
</tr>
</tbody>
</table>
<p>Types are what you think they are. A instance of
<a class="reference external" href="llvm.core.Type.html">llvm.core.Type</a>, or one of its derived classes,
represent a type. llvmpy does not use as many classes to represent
types as does LLVM itself. Some types are represented using
<a class="reference external" href="llvm.core.Type.html">llvm.core.Type</a> itself and the rest are
represented using derived classes of
<a class="reference external" href="llvm.core.Type.html">llvm.core.Type</a>. As usual, an instance is
created via one of the static methods of <a class="reference external" href="llvm.core.Type.html">Type</a>.
These methods return an instance of either
<a class="reference external" href="llvm.core.Type.html">llvm.core.Type</a> itself or one of its derived
classes.</p>
<p>The following table lists all the available types along with the static
method which has to be used to construct it and the name of the class
whose object is actually returned by the static method.</p>
<p>Name | Constructor Method | Class |
—–|:——————:|:—–:| integer of bitwidth <em>n</em> |
Type.int(n) | <a class="reference external" href="llvm.core.IntegerType.html">IntegerType</a> | 32-bit
float | Type.float() | <a class="reference external" href="llvm.core.Type.html">Type</a> | 64-bit double
| Type.double() | <a class="reference external" href="llvm.core.Type.html">Type</a> | 80-bit float |
Type.x86_fp80() | <a class="reference external" href="llvm.core.Type.html">Type</a> | 128-bit float
(112-bit mantissa) | Type.fp128() | <a class="reference external" href="llvm.core.Type.html">Type</a> |
128-bit float (two 64-bits) | Type.ppc_fp128() |
<a class="reference external" href="llvm.core.Type.html">Type</a> | function | Type.function(r, p, v) |
<a class="reference external" href="llvm.core.FunctionType.html">FunctionType</a> | unpacked struct |
Type.struct(eltys, name) | <a class="reference external" href="llvm.core.StructType.html">StructType</a> |
packed struct | Type.packed_struct(eltys, name) |
<a class="reference external" href="llvm.core.StructType.html">StructType</a> | opaque struct |
Type.opaque(name) | <a class="reference external" href="llvm.core.StructType.html">StructType</a> | array
| Type.array(elty, count) | <a class="reference external" href="llvm.core.ArrayType.html">ArrayType</a> |
pointer to value of type <em>pty</em> | Type.pointer(pty, addrspc) |
<a class="reference external" href="llvm.core.PointerType.html">PointerType</a> | vector |
Type.vector(elty, count) | <a class="reference external" href="llvm.core.VectorType.html">VectorType</a> |
void | Type.void() | <a class="reference external" href="llvm.core.Type.html">Type</a> | label |
Type.label() | <a class="reference external" href="llvm.core.Type.html">Type</a> |</p>
<p>The class hierarchy is:</p>
<div class="highlight-python"><pre>Type
IntegerType
FunctionType
StructType
ArrayType
PointerType
VectorType</pre>
</div>
<hr class="docutils" />
<div class="section" id="an-example">
<h1>An Example<a class="headerlink" href="#an-example" title="Permalink to this headline">¶</a></h1>
<p>Here is an example that demonstrates the creation of types:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c">#!/usr/bin/env python</span>
<span class="c"># integers</span>
<span class="n">int_ty</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">int</span><span class="p">()</span> <span class="n">bool_ty</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">int</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="n">int_64bit</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">int</span><span class="p">(</span><span class="mi">64</span><span class="p">)</span>
<span class="c"># floats</span>
<span class="n">sprec_real</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">float</span><span class="p">()</span> <span class="n">dprec_real</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">double</span><span class="p">()</span>
<span class="c"># arrays and vectors</span>
<span class="n">intar_ty</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">array</span><span class="p">(</span> <span class="n">int_ty</span><span class="p">,</span> <span class="mi">10</span> <span class="p">)</span> <span class="c"># "typedef int intar_ty[10];"</span>
<span class="n">twodim</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">array</span><span class="p">(</span> <span class="n">intar_ty</span> <span class="p">,</span> <span class="mi">10</span> <span class="p">)</span> <span class="c"># "typedef int twodim[10][10];"</span>
<span class="n">vec</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">array</span><span class="p">(</span> <span class="n">int_ty</span><span class="p">,</span> <span class="mi">10</span> <span class="p">)</span>
<span class="c"># structures</span>
<span class="n">s1_ty</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">struct</span><span class="p">(</span> <span class="p">[</span> <span class="n">int_ty</span><span class="p">,</span> <span class="n">sprec_real</span> <span class="p">]</span> <span class="p">)</span> <span class="c"># "struct s1_ty { int</span>
<span class="n">v1</span><span class="p">;</span> <span class="nb">float</span> <span class="n">v2</span><span class="p">;</span> <span class="p">};</span><span class="s">"</span>
<span class="c"># pointers</span>
<span class="n">intptr_ty</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">pointer</span><span class="p">(</span><span class="n">int_ty</span><span class="p">)</span> <span class="c"># "typedef int \*intptr_ty;"</span>
<span class="c"># functions</span>
<span class="n">f1</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">function</span><span class="p">(</span> <span class="n">int_ty</span><span class="p">,</span> <span class="p">[</span> <span class="n">int_ty</span> <span class="p">]</span> <span class="p">)</span> <span class="c"># functions that take 1</span>
<span class="n">int_ty</span> <span class="ow">and</span> <span class="k">return</span> <span class="mi">1</span> <span class="n">int_ty</span>
<span class="n">f2</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">function</span><span class="p">(</span> <span class="n">Type</span><span class="o">.</span><span class="n">void</span><span class="p">(),</span> <span class="p">[</span> <span class="n">int_ty</span><span class="p">,</span> <span class="n">int_ty</span> <span class="p">]</span> <span class="p">)</span> <span class="c"># functions that</span>
<span class="n">take</span> <span class="mi">2</span> <span class="n">int_tys</span> <span class="ow">and</span> <span class="k">return</span> <span class="n">nothing</span>
<span class="n">f3</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">function</span><span class="p">(</span> <span class="n">Type</span><span class="o">.</span><span class="n">void</span><span class="p">(),</span> <span class="p">(</span> <span class="n">int_ty</span><span class="p">,</span> <span class="n">int_ty</span> <span class="p">)</span> <span class="p">)</span> <span class="c"># same as f2;</span>
<span class="nb">any</span> <span class="n">iterable</span> <span class="n">can</span> <span class="n">be</span> <span class="n">used</span>
<span class="n">fnargs</span> <span class="o">=</span> <span class="p">[</span> <span class="n">Type</span><span class="o">.</span><span class="n">pointer</span><span class="p">(</span> <span class="n">Type</span><span class="o">.</span><span class="n">int</span><span class="p">(</span><span class="mi">8</span><span class="p">)</span> <span class="p">)</span> <span class="p">]</span> <span class="n">printf</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">function</span><span class="p">(</span>
<span class="n">Type</span><span class="o">.</span><span class="n">int</span><span class="p">(),</span> <span class="n">fnargs</span><span class="p">,</span> <span class="bp">True</span> <span class="p">)</span> <span class="c"># variadic function</span>
</pre></div>
</div>
</div>
<hr class="docutils" />
<div class="section" id="another-example-recursive-type">
<h1>Another Example: Recursive Type<a class="headerlink" href="#another-example-recursive-type" title="Permalink to this headline">¶</a></h1>
<p>The type system was rewritten in LLVM 3.0. The old opaque type was
removed. Instead, identified <tt class="docutils literal"><span class="pre">StructType</span></tt> can now be defined without a
body. Doing so creates a opaque structure. One can then set the body
after the construction of a structure.</p>
<p>(See <a class="reference external" href="http://blog.llvm.org/2011/11/llvm-30-type-system-rewrite.html">LLVM
Blog</a>
for detail about the new type system.)</p>
<p>The following code defines a opaque structure, named “mystruct”. The
body is defined after the construction using <tt class="docutils literal"><span class="pre">StructType.set_body</span></tt>.
The second subtype is a pointer to a “mystruct” type.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">ts</span> <span class="o">=</span> <span class="n">Type</span><span class="o">.</span><span class="n">opaque</span><span class="p">(</span><span class="s">'mystruct'</span><span class="p">)</span>
<span class="n">ts</span><span class="o">.</span><span class="n">set_body</span><span class="p">([</span><span class="n">Type</span><span class="o">.</span><span class="n">int</span><span class="p">(),</span> <span class="n">Type</span><span class="o">.</span><span class="n">pointer</span><span class="p">(</span><span class="n">ts</span><span class="p">)])</span>
</pre></div>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">An Example</a></li>
<li><a class="reference internal" href="#another-example-recursive-type">Another Example: Recursive Type</a></li>
</ul>
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/doc/types.txt"
rel="nofollow">Show Source</a></li>
</ul>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li><a href="../index.html">llvmpy tag: 0.12.0 documentation</a> »</li>
</ul>
</div>
<div class="footer">
© Copyright 2013, Mahadevan R (2008-2010), Continuum Analytics (2012-2013).
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
</div>
</body>
</html>
