hc
2023-11-06 15ade055295d13f95d49e3d99b09f3bbfb4a43e7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Copyright (C) 1988-2016 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 the
Invariant Sections being "Funding Free Software", the Front-Cover
Texts being (a) (see below), and with the Back-Cover Texts being (b)
(see below).  A copy of the license is included in the section entitled
"GNU Free Documentation License".
 
(a) The FSF's Front-Cover Text is:
 
A GNU Manual
 
(b) The FSF's Back-Cover Text is:
 
You have freedom to copy and modify this GNU Manual, like GNU
     software.  Copies published by the Free Software Foundation raise
     funds for GNU development. -->
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>GNU Compiler Collection (GCC) Internals: Working with declarations</title>
 
<meta name="description" content="GNU Compiler Collection (GCC) Internals: Working with declarations">
<meta name="keywords" content="GNU Compiler Collection (GCC) Internals: Working with declarations">
<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="Option-Index.html#Option-Index" rel="index" title="Option Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Declarations.html#Declarations" rel="up" title="Declarations">
<link href="Internal-structure.html#Internal-structure" rel="next" title="Internal structure">
<link href="Declarations.html#Declarations" rel="prev" title="Declarations">
<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="Working-with-declarations"></a>
<div class="header">
<p>
Next: <a href="Internal-structure.html#Internal-structure" accesskey="n" rel="next">Internal structure</a>, Up: <a href="Declarations.html#Declarations" accesskey="u" rel="up">Declarations</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Working-with-declarations-1"></a>
<h4 class="subsection">10.4.1 Working with declarations</h4>
 
<p>Some macros can be used with any kind of declaration.  These include:
</p><dl compact="compact">
<dt><code>DECL_NAME</code>
<a name="index-DECL_005fNAME"></a>
</dt>
<dd><p>This macro returns an <code>IDENTIFIER_NODE</code> giving the name of the
entity.
</p>
</dd>
<dt><code>TREE_TYPE</code>
<a name="index-TREE_005fTYPE-2"></a>
</dt>
<dd><p>This macro returns the type of the entity declared.
</p>
</dd>
<dt><code>EXPR_FILENAME</code>
<a name="index-EXPR_005fFILENAME"></a>
</dt>
<dd><p>This macro returns the name of the file in which the entity was
declared, as a <code>char*</code>.  For an entity declared implicitly by the
compiler (like <code>__builtin_memcpy</code>), this will be the string
<code>&quot;&lt;internal&gt;&quot;</code>.
</p>
</dd>
<dt><code>EXPR_LINENO</code>
<a name="index-EXPR_005fLINENO"></a>
</dt>
<dd><p>This macro returns the line number at which the entity was declared, as
an <code>int</code>.
</p>
</dd>
<dt><code>DECL_ARTIFICIAL</code>
<a name="index-DECL_005fARTIFICIAL"></a>
</dt>
<dd><p>This predicate holds if the declaration was implicitly generated by the
compiler.  For example, this predicate will hold of an implicitly
declared member function, or of the <code>TYPE_DECL</code> implicitly
generated for a class type.  Recall that in C++ code like:
</p><div class="smallexample">
<pre class="smallexample">struct S {};
</pre></div>
<p>is roughly equivalent to C code like:
</p><div class="smallexample">
<pre class="smallexample">struct S {};
typedef struct S S;
</pre></div>
<p>The implicitly generated <code>typedef</code> declaration is represented by a
<code>TYPE_DECL</code> for which <code>DECL_ARTIFICIAL</code> holds.
</p>
</dd>
</dl>
 
<p>The various kinds of declarations include:
</p><dl compact="compact">
<dt><code>LABEL_DECL</code></dt>
<dd><p>These nodes are used to represent labels in function bodies.  For more
information, see <a href="Functions.html#Functions">Functions</a>.  These nodes only appear in block
scopes.
</p>
</dd>
<dt><code>CONST_DECL</code></dt>
<dd><p>These nodes are used to represent enumeration constants.  The value of
the constant is given by <code>DECL_INITIAL</code> which will be an
<code>INTEGER_CST</code> with the same type as the <code>TREE_TYPE</code> of the
<code>CONST_DECL</code>, i.e., an <code>ENUMERAL_TYPE</code>.
</p>
</dd>
<dt><code>RESULT_DECL</code></dt>
<dd><p>These nodes represent the value returned by a function.  When a value is
assigned to a <code>RESULT_DECL</code>, that indicates that the value should
be returned, via bitwise copy, by the function.  You can use
<code>DECL_SIZE</code> and <code>DECL_ALIGN</code> on a <code>RESULT_DECL</code>, just as
with a <code>VAR_DECL</code>.
</p>
</dd>
<dt><code>TYPE_DECL</code></dt>
<dd><p>These nodes represent <code>typedef</code> declarations.  The <code>TREE_TYPE</code>
is the type declared to have the name given by <code>DECL_NAME</code>.  In
some cases, there is no associated name.
</p>
</dd>
<dt><code>VAR_DECL</code></dt>
<dd><p>These nodes represent variables with namespace or block scope, as well
as static data members.  The <code>DECL_SIZE</code> and <code>DECL_ALIGN</code> are
analogous to <code>TYPE_SIZE</code> and <code>TYPE_ALIGN</code>.  For a declaration,
you should always use the <code>DECL_SIZE</code> and <code>DECL_ALIGN</code> rather
than the <code>TYPE_SIZE</code> and <code>TYPE_ALIGN</code> given by the
<code>TREE_TYPE</code>, since special attributes may have been applied to the
variable to give it a particular size and alignment.  You may use the
predicates <code>DECL_THIS_STATIC</code> or <code>DECL_THIS_EXTERN</code> to test
whether the storage class specifiers <code>static</code> or <code>extern</code> were
used to declare a variable.
</p>
<p>If this variable is initialized (but does not require a constructor),
the <code>DECL_INITIAL</code> will be an expression for the initializer.  The
initializer should be evaluated, and a bitwise copy into the variable
performed.  If the <code>DECL_INITIAL</code> is the <code>error_mark_node</code>,
there is an initializer, but it is given by an explicit statement later
in the code; no bitwise copy is required.
</p>
<p>GCC provides an extension that allows either automatic variables, or
global variables, to be placed in particular registers.  This extension
is being used for a particular <code>VAR_DECL</code> if <code>DECL_REGISTER</code>
holds for the <code>VAR_DECL</code>, and if <code>DECL_ASSEMBLER_NAME</code> is not
equal to <code>DECL_NAME</code>.  In that case, <code>DECL_ASSEMBLER_NAME</code> is
the name of the register into which the variable will be placed.
</p>
</dd>
<dt><code>PARM_DECL</code></dt>
<dd><p>Used to represent a parameter to a function.  Treat these nodes
similarly to <code>VAR_DECL</code> nodes.  These nodes only appear in the
<code>DECL_ARGUMENTS</code> for a <code>FUNCTION_DECL</code>.
</p>
<p>The <code>DECL_ARG_TYPE</code> for a <code>PARM_DECL</code> is the type that will
actually be used when a value is passed to this function.  It may be a
wider type than the <code>TREE_TYPE</code> of the parameter; for example, the
ordinary type might be <code>short</code> while the <code>DECL_ARG_TYPE</code> is
<code>int</code>.
</p>
</dd>
<dt><code>DEBUG_EXPR_DECL</code></dt>
<dd><p>Used to represent an anonymous debug-information temporary created to
hold an expression as it is optimized away, so that its value can be
referenced in debug bind statements.
</p>
</dd>
<dt><code>FIELD_DECL</code></dt>
<dd><p>These nodes represent non-static data members.  The <code>DECL_SIZE</code> and
<code>DECL_ALIGN</code> behave as for <code>VAR_DECL</code> nodes.
The position of the field within the parent record is specified by a
combination of three attributes.  <code>DECL_FIELD_OFFSET</code> is the position,
counting in bytes, of the <code>DECL_OFFSET_ALIGN</code>-bit sized word containing
the bit of the field closest to the beginning of the structure.
<code>DECL_FIELD_BIT_OFFSET</code> is the bit offset of the first bit of the field
within this word; this may be nonzero even for fields that are not bit-fields,
since <code>DECL_OFFSET_ALIGN</code> may be greater than the natural alignment
of the field&rsquo;s type.
</p>
<p>If <code>DECL_C_BIT_FIELD</code> holds, this field is a bit-field.  In a bit-field,
<code>DECL_BIT_FIELD_TYPE</code> also contains the type that was originally
specified for it, while DECL_TYPE may be a modified type with lesser precision,
according to the size of the bit field.
</p>
</dd>
<dt><code>NAMESPACE_DECL</code></dt>
<dd><p>Namespaces provide a name hierarchy for other declarations.  They
appear in the <code>DECL_CONTEXT</code> of other <code>_DECL</code> nodes.
</p>
</dd>
</dl>
 
<hr>
<div class="header">
<p>
Next: <a href="Internal-structure.html#Internal-structure" accesskey="n" rel="next">Internal structure</a>, Up: <a href="Declarations.html#Declarations" accesskey="u" rel="up">Declarations</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p>
</div>
 
 
 
</body>
</html>