Blame - src/libmach/gxxint_15.html - plan9

blob: cdee7dda202aa9ec3d3a57982d1419d6cfe0a1da [file] [log] [blame]

rsc	c8661ff	2005-11-29 04:05:50 +0000	[diff] [blame]	1	<HTML>
				2	<HEAD>
				3	<!-- This HTML file has been created by texi2html 1.52
				4	from gxxint.texi on 27 August 1999 -->
				5
				6	<TITLE>G++ internals - Mangling</TITLE>
				7	</HEAD>
				8	<BODY>
				9	Go to the <A HREF="gxxint_1.html">first</A>, <A HREF="gxxint_14.html">previous</A>, <A HREF="gxxint_16.html">next</A>, <A HREF="gxxint_16.html">last</A> section, <A HREF="gxxint_toc.html">table of contents</A>.
				10	<P><HR><P>
				11
				12
				13	<H2><A NAME="SEC20" HREF="gxxint_toc.html#TOC20">Function name mangling for C++ and Java</A></H2>
				14
				15	<P>
				16	Both C++ and Jave provide overloaded function and methods,
				17	which are methods with the same types but different parameter lists.
				18	Selecting the correct version is done at compile time.
				19	Though the overloaded functions have the same name in the source code,
				20	they need to be translated into different assembler-level names,
				21	since typical assemblers and linkers cannot handle overloading.
				22	This process of encoding the parameter types with the method name
				23	into a unique name is called <EM>name mangling</EM>. The inverse
				24	process is called <EM>demangling</EM>.
				25
				26	</P>
				27	<P>
				28	It is convenient that C++ and Java use compatible mangling schemes,
				29	since the makes life easier for tools such as gdb, and it eases
				30	integration between C++ and Java.
				31
				32	</P>
				33	<P>
				34	Note there is also a standard "Jave Native Interface" (JNI) which
				35	implements a different calling convention, and uses a different
				36	mangling scheme. The JNI is a rather abstract ABI so Java can call methods
				37	written in C or C++;
				38	we are concerned here about a lower-level interface primarily
				39	intended for methods written in Java, but that can also be used for C++
				40	(and less easily C).
				41
				42	</P>
				43
				44
				45	<H3><A NAME="SEC21" HREF="gxxint_toc.html#TOC21">Method name mangling</A></H3>
				46
				47	<P>
				48	C++ mangles a method by emitting the function name, followed by <CODE>__</CODE>,
				49	followed by encodings of any method qualifiers (such as <CODE>const</CODE>),
				50	followed by the mangling of the method's class,
				51	followed by the mangling of the parameters, in order.
				52
				53	</P>
				54	<P>
				55	For example <CODE>Foo::bar(int, long) const</CODE> is mangled
				56	as <SAMP>`bar__C3Fooil'</SAMP>.
				57
				58	</P>
				59	<P>
				60	For a constructor, the method name is left out.
				61	That is <CODE>Foo::Foo(int, long) const</CODE> is mangled
				62	as <SAMP>`__C3Fooil'</SAMP>.
				63
				64	</P>
				65	<P>
				66	GNU Java does the same.
				67
				68	</P>
				69
				70
				71	<H3><A NAME="SEC22" HREF="gxxint_toc.html#TOC22">Primitive types</A></H3>
				72
				73	<P>
				74	The C++ types <CODE>int</CODE>, <CODE>long</CODE>, <CODE>short</CODE>, <CODE>char</CODE>,
				75	and <CODE>long long</CODE> are mangled as <SAMP>`i'</SAMP>, <SAMP>`l'</SAMP>,
				76	<SAMP>`s'</SAMP>, <SAMP>`c'</SAMP>, and <SAMP>`x'</SAMP>, respectively.
				77	The corresponding unsigned types have <SAMP>`U'</SAMP> prefixed
				78	to the mangling. The type <CODE>signed char</CODE> is mangled <SAMP>`Sc'</SAMP>.
				79
				80	</P>
				81	<P>
				82	The C++ and Java floating-point types <CODE>float</CODE> and <CODE>double</CODE>
				83	are mangled as <SAMP>`f'</SAMP> and <SAMP>`d'</SAMP> respectively.
				84
				85	</P>
				86	<P>
				87	The C++ <CODE>bool</CODE> type and the Java <CODE>boolean</CODE> type are
				88	mangled as <SAMP>`b'</SAMP>.
				89
				90	</P>
				91	<P>
				92	The C++ <CODE>wchar_t</CODE> and the Java <CODE>char</CODE> types are
				93	mangled as <SAMP>`w'</SAMP>.
				94
				95	</P>
				96	<P>
				97	The Java integral types <CODE>byte</CODE>, <CODE>short</CODE>, <CODE>int</CODE>
				98	and <CODE>long</CODE> are mangled as <SAMP>`c'</SAMP>, <SAMP>`s'</SAMP>, <SAMP>`i'</SAMP>,
				99	and <SAMP>`x'</SAMP>, respectively.
				100
				101	</P>
				102	<P>
				103	C++ code that has included <CODE>javatypes.h</CODE> will mangle
				104	the typedefs <CODE>jbyte</CODE>, <CODE>jshort</CODE>, <CODE>jint</CODE>
				105	and <CODE>jlong</CODE> as respectively <SAMP>`c'</SAMP>, <SAMP>`s'</SAMP>, <SAMP>`i'</SAMP>,
				106	and <SAMP>`x'</SAMP>. (This has not been implemented yet.)
				107
				108	</P>
				109
				110
				111	<H3><A NAME="SEC23" HREF="gxxint_toc.html#TOC23">Mangling of simple names</A></H3>
				112
				113	<P>
				114	A simple class, package, template, or namespace name is
				115	encoded as the number of characters in the name, followed by
				116	the actual characters. Thus the class <CODE>Foo</CODE>
				117	is encoded as <SAMP>`3Foo'</SAMP>.
				118
				119	</P>
				120	<P>
				121	If any of the characters in the name are not alphanumeric
				122	(i.e not one of the standard ASCII letters, digits, or '_'),
				123	or the initial character is a digit, then the name is
				124	mangled as a sequence of encoded Unicode letters.
				125	A Unicode encoding starts with a <SAMP>`U'</SAMP> to indicate
				126	that Unicode escapes are used, followed by the number of
				127	bytes used by the Unicode encoding, followed by the bytes
				128	representing the encoding. ASSCI letters and
				129	non-initial digits are encoded without change. However, all
				130	other characters (including underscore and initial digits) are
				131	translated into a sequence starting with an underscore,
				132	followed by the big-endian 4-hex-digit lower-case encoding of the character.
				133
				134	</P>
				135	<P>
				136	If a method name contains Unicode-escaped characters, the
				137	entire mangled method name is followed by a <SAMP>`U'</SAMP>.
				138
				139	</P>
				140	<P>
				141	For example, the method <CODE>X\u0319::M\u002B(int)</CODE> is encoded as
				142	<SAMP>`M_002b__U6X_0319iU'</SAMP>.
				143
				144	</P>
				145
				146
				147	<H3><A NAME="SEC24" HREF="gxxint_toc.html#TOC24">Pointer and reference types</A></H3>
				148
				149	<P>
				150	A C++ pointer type is mangled as <SAMP>`P'</SAMP> followed by the
				151	mangling of the type pointed to.
				152
				153	</P>
				154	<P>
				155	A C++ reference type as mangled as <SAMP>`R'</SAMP> followed by the
				156	mangling of the type referenced.
				157
				158	</P>
				159	<P>
				160	A Java object reference type is equivalent
				161	to a C++ pointer parameter, so we mangle such an parameter type
				162	as <SAMP>`P'</SAMP> followed by the mangling of the class name.
				163
				164	</P>
				165
				166
				167	<H3><A NAME="SEC25" HREF="gxxint_toc.html#TOC25">Qualified names</A></H3>
				168
				169	<P>
				170	Both C++ and Java allow a class to be lexically nested inside another
				171	class. C++ also supports namespaces (not yet implemented by G++).
				172	Java also supports packages.
				173
				174	</P>
				175	<P>
				176	These are all mangled the same way: First the letter <SAMP>`Q'</SAMP>
				177	indicates that we are emitting a qualified name.
				178	That is followed by the number of parts in the qualified name.
				179	If that number is 9 or less, it is emitted with no delimiters.
				180	Otherwise, an underscore is written before and after the count.
				181	Then follows each part of the qualified name, as described above.
				182
				183	</P>
				184	<P>
				185	For example <CODE>Foo::\u0319::Bar</CODE> is encoded as
				186	<SAMP>`Q33FooU5_03193Bar'</SAMP>.
				187
				188	</P>
				189
				190
				191	<H3><A NAME="SEC26" HREF="gxxint_toc.html#TOC26">Templates</A></H3>
				192
				193	<P>
				194	A class template instantiation is encoded as the letter <SAMP>`t'</SAMP>,
				195	followed by the encoding of the template name, followed
				196	the number of template parameters, followed by encoding of the template
				197	parameters. If a template parameter is a type, it is written
				198	as a <SAMP>`Z'</SAMP> followed by the encoding of the type.
				199
				200	</P>
				201	<P>
				202	A function template specialization (either an instantiation or an
				203	explicit specialization) is encoded by an <SAMP>`H'</SAMP> followed by the
				204	encoding of the template parameters, as described above, followed by
				205	an <SAMP>`_'</SAMP>, the encoding of the argument types template function (not the
				206	specialization), another <SAMP>`_'</SAMP>, and the return type. (Like the
				207	argument types, the return type is the return type of the function
				208	template, not the specialization.) Template parameters in the argument
				209	and return types are encoded by an <SAMP>`X'</SAMP> for type parameters, or a
				210	<SAMP>`Y'</SAMP> for constant parameters, and an index indicating their position
				211	in the template parameter list declaration.
				212
				213	</P>
				214
				215
				216	<H3><A NAME="SEC27" HREF="gxxint_toc.html#TOC27">Arrays</A></H3>
				217
				218	<P>
				219	C++ array types are mangled by emitting <SAMP>`A'</SAMP>, followed by
				220	the length of the array, followed by an <SAMP>`_'</SAMP>, followed by
				221	the mangling of the element type. Of course, normally
				222	array parameter types decay into a pointer types, so you
				223	don't see this.
				224
				225	</P>
				226	<P>
				227	Java arrays are objects. A Java type <CODE>T[]</CODE> is mangled
				228	as if it were the C++ type <CODE>JArray<T></CODE>.
				229	For example <CODE>java.lang.String[]</CODE> is encoded as
				230	<SAMP>`Pt6JArray1ZPQ34java4lang6String'</SAMP>.
				231
				232	</P>
				233
				234
				235	<H3><A NAME="SEC28" HREF="gxxint_toc.html#TOC28">Table of demangling code characters</A></H3>
				236
				237	<P>
				238	The following special characters are used in mangling:
				239
				240	</P>
				241	<DL COMPACT>
				242
				243	<DT><SAMP>`A'</SAMP>
				244	<DD>
				245	Indicates a C++ array type.
				246
				247	<DT><SAMP>`b'</SAMP>
				248	<DD>
				249	Encodes the C++ <CODE>bool</CODE> type,
				250	and the Java <CODE>boolean</CODE> type.
				251
				252	<DT><SAMP>`c'</SAMP>
				253	<DD>
				254	Encodes the C++ <CODE>char</CODE> type, and the Java <CODE>byte</CODE> type.
				255
				256	<DT><SAMP>`C'</SAMP>
				257	<DD>
				258	A modifier to indicate a <CODE>const</CODE> type.
				259	Also used to indicate a <CODE>const</CODE> member function
				260	(in which cases it precedes the encoding of the method's class).
				261
				262	<DT><SAMP>`d'</SAMP>
				263	<DD>
				264	Encodes the C++ and Java <CODE>double</CODE> types.
				265
				266	<DT><SAMP>`e'</SAMP>
				267	<DD>
				268	Indicates extra unknown arguments <CODE>...</CODE>.
				269
				270	<DT><SAMP>`f'</SAMP>
				271	<DD>
				272	Encodes the C++ and Java <CODE>float</CODE> types.
				273
				274	<DT><SAMP>`F'</SAMP>
				275	<DD>
				276	Used to indicate a function type.
				277
				278	<DT><SAMP>`H'</SAMP>
				279	<DD>
				280	Used to indicate a template function.
				281
				282	<DT><SAMP>`i'</SAMP>
				283	<DD>
				284	Encodes the C++ and Java <CODE>int</CODE> types.
				285
				286	<DT><SAMP>`J'</SAMP>
				287	<DD>
				288	Indicates a complex type.
				289
				290	<DT><SAMP>`l'</SAMP>
				291	<DD>
				292	Encodes the C++ <CODE>long</CODE> type.
				293
				294	<DT><SAMP>`P'</SAMP>
				295	<DD>
				296	Indicates a pointer type. Followed by the type pointed to.
				297
				298	<DT><SAMP>`Q'</SAMP>
				299	<DD>
				300	Used to mangle qualified names, which arise from nested classes.
				301	Should also be used for namespaces (?).
				302	In Java used to mangle package-qualified names, and inner classes.
				303
				304	<DT><SAMP>`r'</SAMP>
				305	<DD>
				306	Encodes the GNU C++ <CODE>long double</CODE> type.
				307
				308	<DT><SAMP>`R'</SAMP>
				309	<DD>
				310	Indicates a reference type. Followed by the referenced type.
				311
				312	<DT><SAMP>`s'</SAMP>
				313	<DD>
				314	Encodes the C++ and java <CODE>short</CODE> types.
				315
				316	<DT><SAMP>`S'</SAMP>
				317	<DD>
				318	A modifier that indicates that the following integer type is signed.
				319	Only used with <CODE>char</CODE>.
				320
				321	Also used as a modifier to indicate a static member function.
				322
				323	<DT><SAMP>`t'</SAMP>
				324	<DD>
				325	Indicates a template instantiation.
				326
				327	<DT><SAMP>`T'</SAMP>
				328	<DD>
				329	A back reference to a previously seen type.
				330
				331	<DT><SAMP>`U'</SAMP>
				332	<DD>
				333	A modifier that indicates that the following integer type is unsigned.
				334	Also used to indicate that the following class or namespace name
				335	is encoded using Unicode-mangling.
				336
				337	<DT><SAMP>`v'</SAMP>
				338	<DD>
				339	Encodes the C++ and Java <CODE>void</CODE> types.
				340
				341	<DT><SAMP>`V'</SAMP>
				342	<DD>
				343	A modified for a <CODE>const</CODE> type or method.
				344
				345	<DT><SAMP>`w'</SAMP>
				346	<DD>
				347	Encodes the C++ <CODE>wchar_t</CODE> type, and the Java <CODE>char</CODE> types.
				348
				349	<DT><SAMP>`x'</SAMP>
				350	<DD>
				351	Encodes the GNU C++ <CODE>long long</CODE> type, and the Java <CODE>long</CODE> type.
				352
				353	<DT><SAMP>`X'</SAMP>
				354	<DD>
				355	Encodes a template type parameter, when part of a function type.
				356
				357	<DT><SAMP>`Y'</SAMP>
				358	<DD>
				359	Encodes a template constant parameter, when part of a function type.
				360
				361	<DT><SAMP>`Z'</SAMP>
				362	<DD>
				363	Used for template type parameters.
				364
				365	</DL>
				366
				367	<P>
				368	The letters <SAMP>`G'</SAMP>, <SAMP>`M'</SAMP>, <SAMP>`O'</SAMP>, and <SAMP>`p'</SAMP>
				369	also seem to be used for obscure purposes ...
				370
				371	</P>
				372	<P><HR><P>
				373	Go to the <A HREF="gxxint_1.html">first</A>, <A HREF="gxxint_14.html">previous</A>, <A HREF="gxxint_16.html">next</A>, <A HREF="gxxint_16.html">last</A> section, <A HREF="gxxint_toc.html">table of contents</A>.
				374	</BODY>
				375	</HTML>