]>
Commit | Line | Data |
---|---|---|
c63539ff ML |
1 | .. |
2 | Copyright 1988-2022 Free Software Foundation, Inc. | |
3 | This is part of the GCC manual. | |
4 | For copying conditions, see the copyright.rst file. | |
5 | ||
6 | .. _label-output: | |
7 | ||
8 | Output and Generation of Labels | |
9 | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | |
10 | ||
11 | .. prevent bad page break with this line | |
12 | ||
13 | This is about outputting labels. | |
14 | ||
15 | .. index:: assemble_name | |
16 | ||
17 | .. c:macro:: ASM_OUTPUT_LABEL (stream, name) | |
18 | ||
19 | A C statement (sans semicolon) to output to the stdio stream | |
20 | :samp:`{stream}` the assembler definition of a label named :samp:`{name}`. | |
21 | Use the expression ``assemble_name (stream, name)`` to | |
22 | output the name itself; before and after that, output the additional | |
23 | assembler syntax for defining the name, and a newline. A default | |
24 | definition of this macro is provided which is correct for most systems. | |
25 | ||
26 | .. c:macro:: ASM_OUTPUT_FUNCTION_LABEL (stream, name, decl) | |
27 | ||
28 | A C statement (sans semicolon) to output to the stdio stream | |
29 | :samp:`{stream}` the assembler definition of a label named :samp:`{name}` of | |
30 | a function. | |
31 | Use the expression ``assemble_name (stream, name)`` to | |
32 | output the name itself; before and after that, output the additional | |
33 | assembler syntax for defining the name, and a newline. A default | |
34 | definition of this macro is provided which is correct for most systems. | |
35 | ||
36 | If this macro is not defined, then the function name is defined in the | |
37 | usual manner as a label (by means of ``ASM_OUTPUT_LABEL``). | |
38 | ||
39 | .. index:: assemble_name_raw | |
40 | ||
41 | .. c:macro:: ASM_OUTPUT_INTERNAL_LABEL (stream, name) | |
42 | ||
43 | Identical to ``ASM_OUTPUT_LABEL``, except that :samp:`{name}` is known | |
44 | to refer to a compiler-generated label. The default definition uses | |
45 | ``assemble_name_raw``, which is like ``assemble_name`` except | |
46 | that it is more efficient. | |
47 | ||
48 | .. c:macro:: SIZE_ASM_OP | |
49 | ||
50 | A C string containing the appropriate assembler directive to specify the | |
51 | size of a symbol, without any arguments. On systems that use ELF, the | |
52 | default (in :samp:`config/elfos.h`) is :samp:`"\\t.size\\t"`; on other | |
53 | systems, the default is not to define this macro. | |
54 | ||
55 | Define this macro only if it is correct to use the default definitions | |
56 | of ``ASM_OUTPUT_SIZE_DIRECTIVE`` and ``ASM_OUTPUT_MEASURED_SIZE`` | |
57 | for your system. If you need your own custom definitions of those | |
58 | macros, or if you do not need explicit symbol sizes at all, do not | |
59 | define this macro. | |
60 | ||
61 | .. c:macro:: ASM_OUTPUT_SIZE_DIRECTIVE (stream, name, size) | |
62 | ||
63 | A C statement (sans semicolon) to output to the stdio stream | |
64 | :samp:`{stream}` a directive telling the assembler that the size of the | |
65 | symbol :samp:`{name}` is :samp:`{size}`. :samp:`{size}` is a ``HOST_WIDE_INT``. | |
66 | If you define ``SIZE_ASM_OP``, a default definition of this macro is | |
67 | provided. | |
68 | ||
69 | .. c:macro:: ASM_OUTPUT_MEASURED_SIZE (stream, name) | |
70 | ||
71 | A C statement (sans semicolon) to output to the stdio stream | |
72 | :samp:`{stream}` a directive telling the assembler to calculate the size of | |
73 | the symbol :samp:`{name}` by subtracting its address from the current | |
74 | address. | |
75 | ||
76 | If you define ``SIZE_ASM_OP``, a default definition of this macro is | |
77 | provided. The default assumes that the assembler recognizes a special | |
78 | :samp:`.` symbol as referring to the current address, and can calculate | |
79 | the difference between this and another symbol. If your assembler does | |
80 | not recognize :samp:`.` or cannot do calculations with it, you will need | |
81 | to redefine ``ASM_OUTPUT_MEASURED_SIZE`` to use some other technique. | |
82 | ||
83 | .. c:macro:: NO_DOLLAR_IN_LABEL | |
84 | ||
85 | Define this macro if the assembler does not accept the character | |
86 | :samp:`$` in label names. By default constructors and destructors in | |
87 | G++ have :samp:`$` in the identifiers. If this macro is defined, | |
88 | :samp:`.` is used instead. | |
89 | ||
90 | .. c:macro:: NO_DOT_IN_LABEL | |
91 | ||
92 | Define this macro if the assembler does not accept the character | |
93 | :samp:`.` in label names. By default constructors and destructors in G++ | |
94 | have names that use :samp:`.`. If this macro is defined, these names | |
95 | are rewritten to avoid :samp:`.`. | |
96 | ||
97 | .. c:macro:: TYPE_ASM_OP | |
98 | ||
99 | A C string containing the appropriate assembler directive to specify the | |
100 | type of a symbol, without any arguments. On systems that use ELF, the | |
101 | default (in :samp:`config/elfos.h`) is :samp:`"\\t.type\\t"`; on other | |
102 | systems, the default is not to define this macro. | |
103 | ||
104 | Define this macro only if it is correct to use the default definition of | |
105 | ``ASM_OUTPUT_TYPE_DIRECTIVE`` for your system. If you need your own | |
106 | custom definition of this macro, or if you do not need explicit symbol | |
107 | types at all, do not define this macro. | |
108 | ||
109 | .. c:macro:: TYPE_OPERAND_FMT | |
110 | ||
111 | A C string which specifies (using ``printf`` syntax) the format of | |
112 | the second operand to ``TYPE_ASM_OP``. On systems that use ELF, the | |
113 | default (in :samp:`config/elfos.h`) is :samp:`"@%s"`; on other systems, | |
114 | the default is not to define this macro. | |
115 | ||
116 | Define this macro only if it is correct to use the default definition of | |
117 | ``ASM_OUTPUT_TYPE_DIRECTIVE`` for your system. If you need your own | |
118 | custom definition of this macro, or if you do not need explicit symbol | |
119 | types at all, do not define this macro. | |
120 | ||
121 | .. c:macro:: ASM_OUTPUT_TYPE_DIRECTIVE (stream, type) | |
122 | ||
123 | A C statement (sans semicolon) to output to the stdio stream | |
124 | :samp:`{stream}` a directive telling the assembler that the type of the | |
125 | symbol :samp:`{name}` is :samp:`{type}`. :samp:`{type}` is a C string; currently, | |
126 | that string is always either :samp:`"function"` or :samp:`"object"`, but | |
127 | you should not count on this. | |
128 | ||
129 | If you define ``TYPE_ASM_OP`` and ``TYPE_OPERAND_FMT``, a default | |
130 | definition of this macro is provided. | |
131 | ||
132 | .. c:macro:: ASM_DECLARE_FUNCTION_NAME (stream, name, decl) | |
133 | ||
134 | A C statement (sans semicolon) to output to the stdio stream | |
135 | :samp:`{stream}` any text necessary for declaring the name :samp:`{name}` of a | |
136 | function which is being defined. This macro is responsible for | |
137 | outputting the label definition (perhaps using | |
138 | ``ASM_OUTPUT_FUNCTION_LABEL``). The argument :samp:`{decl}` is the | |
139 | ``FUNCTION_DECL`` tree node representing the function. | |
140 | ||
141 | If this macro is not defined, then the function name is defined in the | |
142 | usual manner as a label (by means of ``ASM_OUTPUT_FUNCTION_LABEL``). | |
143 | ||
144 | You may wish to use ``ASM_OUTPUT_TYPE_DIRECTIVE`` in the definition | |
145 | of this macro. | |
146 | ||
147 | .. c:macro:: ASM_DECLARE_FUNCTION_SIZE (stream, name, decl) | |
148 | ||
149 | A C statement (sans semicolon) to output to the stdio stream | |
150 | :samp:`{stream}` any text necessary for declaring the size of a function | |
151 | which is being defined. The argument :samp:`{name}` is the name of the | |
152 | function. The argument :samp:`{decl}` is the ``FUNCTION_DECL`` tree node | |
153 | representing the function. | |
154 | ||
155 | If this macro is not defined, then the function size is not defined. | |
156 | ||
157 | You may wish to use ``ASM_OUTPUT_MEASURED_SIZE`` in the definition | |
158 | of this macro. | |
159 | ||
160 | .. c:macro:: ASM_DECLARE_COLD_FUNCTION_NAME (stream, name, decl) | |
161 | ||
162 | A C statement (sans semicolon) to output to the stdio stream | |
163 | :samp:`{stream}` any text necessary for declaring the name :samp:`{name}` of a | |
164 | cold function partition which is being defined. This macro is responsible | |
165 | for outputting the label definition (perhaps using | |
166 | ``ASM_OUTPUT_FUNCTION_LABEL``). The argument :samp:`{decl}` is the | |
167 | ``FUNCTION_DECL`` tree node representing the function. | |
168 | ||
169 | If this macro is not defined, then the cold partition name is defined in the | |
170 | usual manner as a label (by means of ``ASM_OUTPUT_LABEL``). | |
171 | ||
172 | You may wish to use ``ASM_OUTPUT_TYPE_DIRECTIVE`` in the definition | |
173 | of this macro. | |
174 | ||
175 | .. c:macro:: ASM_DECLARE_COLD_FUNCTION_SIZE (stream, name, decl) | |
176 | ||
177 | A C statement (sans semicolon) to output to the stdio stream | |
178 | :samp:`{stream}` any text necessary for declaring the size of a cold function | |
179 | partition which is being defined. The argument :samp:`{name}` is the name of the | |
180 | cold partition of the function. The argument :samp:`{decl}` is the | |
181 | ``FUNCTION_DECL`` tree node representing the function. | |
182 | ||
183 | If this macro is not defined, then the partition size is not defined. | |
184 | ||
185 | You may wish to use ``ASM_OUTPUT_MEASURED_SIZE`` in the definition | |
186 | of this macro. | |
187 | ||
188 | .. c:macro:: ASM_DECLARE_OBJECT_NAME (stream, name, decl) | |
189 | ||
190 | A C statement (sans semicolon) to output to the stdio stream | |
191 | :samp:`{stream}` any text necessary for declaring the name :samp:`{name}` of an | |
192 | initialized variable which is being defined. This macro must output the | |
193 | label definition (perhaps using ``ASM_OUTPUT_LABEL``). The argument | |
194 | :samp:`{decl}` is the ``VAR_DECL`` tree node representing the variable. | |
195 | ||
196 | If this macro is not defined, then the variable name is defined in the | |
197 | usual manner as a label (by means of ``ASM_OUTPUT_LABEL``). | |
198 | ||
199 | You may wish to use ``ASM_OUTPUT_TYPE_DIRECTIVE`` and/or | |
200 | ``ASM_OUTPUT_SIZE_DIRECTIVE`` in the definition of this macro. | |
201 | ||
8f2b513c ML |
202 | .. include:: ../tm.rst.in |
203 | :start-after: [TARGET_ASM_DECLARE_CONSTANT_NAME] | |
204 | :end-before: [TARGET_ASM_DECLARE_CONSTANT_NAME] | |
c63539ff | 205 | |
c63539ff ML |
206 | |
207 | .. c:macro:: ASM_DECLARE_REGISTER_GLOBAL (stream, decl, regno, name) | |
208 | ||
209 | A C statement (sans semicolon) to output to the stdio stream | |
210 | :samp:`{stream}` any text necessary for claiming a register :samp:`{regno}` | |
211 | for a global variable :samp:`{decl}` with name :samp:`{name}`. | |
212 | ||
213 | If you don't define this macro, that is equivalent to defining it to do | |
214 | nothing. | |
215 | ||
216 | .. c:macro:: ASM_FINISH_DECLARE_OBJECT (stream, decl, toplevel, atend) | |
217 | ||
218 | A C statement (sans semicolon) to finish up declaring a variable name | |
219 | once the compiler has processed its initializer fully and thus has had a | |
220 | chance to determine the size of an array when controlled by an | |
221 | initializer. This is used on systems where it's necessary to declare | |
222 | something about the size of the object. | |
223 | ||
224 | If you don't define this macro, that is equivalent to defining it to do | |
225 | nothing. | |
226 | ||
227 | You may wish to use ``ASM_OUTPUT_SIZE_DIRECTIVE`` and/or | |
228 | ``ASM_OUTPUT_MEASURED_SIZE`` in the definition of this macro. | |
229 | ||
8f2b513c ML |
230 | .. include:: ../tm.rst.in |
231 | :start-after: [TARGET_ASM_GLOBALIZE_LABEL] | |
232 | :end-before: [TARGET_ASM_GLOBALIZE_LABEL] | |
c63539ff | 233 | |
c63539ff | 234 | |
8f2b513c ML |
235 | .. include:: ../tm.rst.in |
236 | :start-after: [TARGET_ASM_GLOBALIZE_DECL_NAME] | |
237 | :end-before: [TARGET_ASM_GLOBALIZE_DECL_NAME] | |
c63539ff | 238 | |
c63539ff | 239 | |
8f2b513c ML |
240 | .. include:: ../tm.rst.in |
241 | :start-after: [TARGET_ASM_ASSEMBLE_UNDEFINED_DECL] | |
242 | :end-before: [TARGET_ASM_ASSEMBLE_UNDEFINED_DECL] | |
c63539ff | 243 | |
c63539ff ML |
244 | |
245 | .. c:macro:: ASM_WEAKEN_LABEL (stream, name) | |
246 | ||
247 | A C statement (sans semicolon) to output to the stdio stream | |
248 | :samp:`{stream}` some commands that will make the label :samp:`{name}` weak; | |
249 | that is, available for reference from other files but only used if | |
250 | no other definition is available. Use the expression | |
251 | ``assemble_name (stream, name)`` to output the name | |
252 | itself; before and after that, output the additional assembler syntax | |
253 | for making that name weak, and a newline. | |
254 | ||
255 | If you don't define this macro or ``ASM_WEAKEN_DECL``, GCC will not | |
256 | support weak symbols and you should not define the ``SUPPORTS_WEAK`` | |
257 | macro. | |
258 | ||
259 | .. c:macro:: ASM_WEAKEN_DECL (stream, decl, name, value) | |
260 | ||
261 | Combines (and replaces) the function of ``ASM_WEAKEN_LABEL`` and | |
262 | ``ASM_OUTPUT_WEAK_ALIAS``, allowing access to the associated function | |
263 | or variable decl. If :samp:`{value}` is not ``NULL``, this C statement | |
264 | should output to the stdio stream :samp:`{stream}` assembler code which | |
265 | defines (equates) the weak symbol :samp:`{name}` to have the value | |
266 | :samp:`{value}`. If :samp:`{value}` is ``NULL``, it should output commands | |
267 | to make :samp:`{name}` weak. | |
268 | ||
269 | .. c:macro:: ASM_OUTPUT_WEAKREF (stream, decl, name, value) | |
270 | ||
271 | Outputs a directive that enables :samp:`{name}` to be used to refer to | |
272 | symbol :samp:`{value}` with weak-symbol semantics. ``decl`` is the | |
273 | declaration of ``name``. | |
274 | ||
275 | .. c:macro:: SUPPORTS_WEAK | |
276 | ||
277 | A preprocessor constant expression which evaluates to true if the target | |
278 | supports weak symbols. | |
279 | ||
280 | If you don't define this macro, :samp:`defaults.h` provides a default | |
281 | definition. If either ``ASM_WEAKEN_LABEL`` or ``ASM_WEAKEN_DECL`` | |
282 | is defined, the default definition is :samp:`1`; otherwise, it is :samp:`0`. | |
283 | ||
284 | .. c:macro:: TARGET_SUPPORTS_WEAK | |
285 | ||
286 | A C expression which evaluates to true if the target supports weak symbols. | |
287 | ||
288 | If you don't define this macro, :samp:`defaults.h` provides a default | |
289 | definition. The default definition is :samp:`(SUPPORTS_WEAK)`. Define | |
290 | this macro if you want to control weak symbol support with a compiler | |
291 | flag such as :option:`-melf`. | |
292 | ||
293 | .. c:macro:: MAKE_DECL_ONE_ONLY (decl) | |
294 | ||
295 | A C statement (sans semicolon) to mark :samp:`{decl}` to be emitted as a | |
296 | public symbol such that extra copies in multiple translation units will | |
297 | be discarded by the linker. Define this macro if your object file | |
298 | format provides support for this concept, such as the :samp:`COMDAT` | |
299 | section flags in the Microsoft Windows PE/COFF format, and this support | |
300 | requires changes to :samp:`{decl}`, such as putting it in a separate section. | |
301 | ||
302 | .. c:macro:: SUPPORTS_ONE_ONLY | |
303 | ||
304 | A C expression which evaluates to true if the target supports one-only | |
305 | semantics. | |
306 | ||
307 | If you don't define this macro, :samp:`varasm.cc` provides a default | |
308 | definition. If ``MAKE_DECL_ONE_ONLY`` is defined, the default | |
309 | definition is :samp:`1`; otherwise, it is :samp:`0`. Define this macro if | |
310 | you want to control one-only symbol support with a compiler flag, or if | |
311 | setting the ``DECL_ONE_ONLY`` flag is enough to mark a declaration to | |
312 | be emitted as one-only. | |
313 | ||
8f2b513c ML |
314 | .. include:: ../tm.rst.in |
315 | :start-after: [TARGET_ASM_ASSEMBLE_VISIBILITY] | |
316 | :end-before: [TARGET_ASM_ASSEMBLE_VISIBILITY] | |
c63539ff | 317 | |
c63539ff ML |
318 | |
319 | .. c:macro:: TARGET_WEAK_NOT_IN_ARCHIVE_TOC | |
320 | ||
321 | A C expression that evaluates to true if the target's linker expects | |
322 | that weak symbols do not appear in a static archive's table of contents. | |
323 | The default is ``0``. | |
324 | ||
325 | Leaving weak symbols out of an archive's table of contents means that, | |
326 | if a symbol will only have a definition in one translation unit and | |
327 | will have undefined references from other translation units, that | |
328 | symbol should not be weak. Defining this macro to be nonzero will | |
329 | thus have the effect that certain symbols that would normally be weak | |
330 | (explicit template instantiations, and vtables for polymorphic classes | |
331 | with noninline key methods) will instead be nonweak. | |
332 | ||
333 | The C++ ABI requires this macro to be zero. Define this macro for | |
334 | targets where full C++ ABI compliance is impossible and where linker | |
335 | restrictions require weak symbols to be left out of a static archive's | |
336 | table of contents. | |
337 | ||
338 | .. c:macro:: ASM_OUTPUT_EXTERNAL (stream, decl, name) | |
339 | ||
340 | A C statement (sans semicolon) to output to the stdio stream | |
341 | :samp:`{stream}` any text necessary for declaring the name of an external | |
342 | symbol named :samp:`{name}` which is referenced in this compilation but | |
343 | not defined. The value of :samp:`{decl}` is the tree node for the | |
344 | declaration. | |
345 | ||
346 | This macro need not be defined if it does not need to output anything. | |
347 | The GNU assembler and most Unix assemblers don't require anything. | |
348 | ||
8f2b513c ML |
349 | .. include:: ../tm.rst.in |
350 | :start-after: [TARGET_ASM_EXTERNAL_LIBCALL] | |
351 | :end-before: [TARGET_ASM_EXTERNAL_LIBCALL] | |
c63539ff | 352 | |
c63539ff | 353 | |
8f2b513c ML |
354 | .. include:: ../tm.rst.in |
355 | :start-after: [TARGET_ASM_MARK_DECL_PRESERVED] | |
356 | :end-before: [TARGET_ASM_MARK_DECL_PRESERVED] | |
c63539ff | 357 | |
c63539ff ML |
358 | |
359 | .. c:macro:: ASM_OUTPUT_LABELREF (stream, name) | |
360 | ||
361 | A C statement (sans semicolon) to output to the stdio stream | |
362 | :samp:`{stream}` a reference in assembler syntax to a label named | |
363 | :samp:`{name}`. This should add :samp:`_` to the front of the name, if that | |
364 | is customary on your operating system, as it is in most Berkeley Unix | |
365 | systems. This macro is used in ``assemble_name``. | |
366 | ||
8f2b513c ML |
367 | .. include:: ../tm.rst.in |
368 | :start-after: [TARGET_MANGLE_ASSEMBLER_NAME] | |
369 | :end-before: [TARGET_MANGLE_ASSEMBLER_NAME] | |
c63539ff | 370 | |
c63539ff ML |
371 | |
372 | .. c:macro:: ASM_OUTPUT_SYMBOL_REF (stream, sym) | |
373 | ||
374 | A C statement (sans semicolon) to output a reference to | |
375 | ``SYMBOL_REF`` :samp:`{sym}`. If not defined, ``assemble_name`` | |
376 | will be used to output the name of the symbol. This macro may be used | |
377 | to modify the way a symbol is referenced depending on information | |
378 | encoded by ``TARGET_ENCODE_SECTION_INFO``. | |
379 | ||
380 | .. c:macro:: ASM_OUTPUT_LABEL_REF (stream, buf) | |
381 | ||
382 | A C statement (sans semicolon) to output a reference to :samp:`{buf}`, the | |
383 | result of ``ASM_GENERATE_INTERNAL_LABEL``. If not defined, | |
384 | ``assemble_name`` will be used to output the name of the symbol. | |
385 | This macro is not used by ``output_asm_label``, or the ``%l`` | |
386 | specifier that calls it; the intention is that this macro should be set | |
387 | when it is necessary to output a label differently when its address is | |
388 | being taken. | |
389 | ||
8f2b513c ML |
390 | .. include:: ../tm.rst.in |
391 | :start-after: [TARGET_ASM_INTERNAL_LABEL] | |
392 | :end-before: [TARGET_ASM_INTERNAL_LABEL] | |
c63539ff | 393 | |
c63539ff ML |
394 | |
395 | .. c:macro:: ASM_OUTPUT_DEBUG_LABEL (stream, prefix, num) | |
396 | ||
397 | A C statement to output to the stdio stream :samp:`{stream}` a debug info | |
398 | label whose name is made from the string :samp:`{prefix}` and the number | |
399 | :samp:`{num}`. This is useful for VLIW targets, where debug info labels | |
400 | may need to be treated differently than branch target labels. On some | |
401 | systems, branch target labels must be at the beginning of instruction | |
402 | bundles, but debug info labels can occur in the middle of instruction | |
403 | bundles. | |
404 | ||
405 | If this macro is not defined, then ``(*targetm.asm_out.internal_label)`` will be | |
406 | used. | |
407 | ||
408 | .. c:macro:: ASM_GENERATE_INTERNAL_LABEL (string, prefix, num) | |
409 | ||
410 | A C statement to store into the string :samp:`{string}` a label whose name | |
411 | is made from the string :samp:`{prefix}` and the number :samp:`{num}`. | |
412 | ||
413 | This string, when output subsequently by ``assemble_name``, should | |
414 | produce the output that ``(*targetm.asm_out.internal_label)`` would produce | |
415 | with the same :samp:`{prefix}` and :samp:`{num}`. | |
416 | ||
417 | If the string begins with :samp:`*`, then ``assemble_name`` will | |
418 | output the rest of the string unchanged. It is often convenient for | |
419 | ``ASM_GENERATE_INTERNAL_LABEL`` to use :samp:`*` in this way. If the | |
420 | string doesn't start with :samp:`*`, then ``ASM_OUTPUT_LABELREF`` gets | |
421 | to output the string, and may change it. (Of course, | |
422 | ``ASM_OUTPUT_LABELREF`` is also part of your machine description, so | |
423 | you should know what it does on your machine.) | |
424 | ||
425 | .. c:macro:: ASM_FORMAT_PRIVATE_NAME (outvar, name, number) | |
426 | ||
427 | A C expression to assign to :samp:`{outvar}` (which is a variable of type | |
428 | ``char *``) a newly allocated string made from the string | |
429 | :samp:`{name}` and the number :samp:`{number}`, with some suitable punctuation | |
430 | added. Use ``alloca`` to get space for the string. | |
431 | ||
432 | The string will be used as an argument to ``ASM_OUTPUT_LABELREF`` to | |
433 | produce an assembler label for an internal static variable whose name is | |
434 | :samp:`{name}`. Therefore, the string must be such as to result in valid | |
435 | assembler code. The argument :samp:`{number}` is different each time this | |
436 | macro is executed; it prevents conflicts between similarly-named | |
437 | internal static variables in different scopes. | |
438 | ||
439 | Ideally this string should not be a valid C identifier, to prevent any | |
440 | conflict with the user's own symbols. Most assemblers allow periods | |
441 | or percent signs in assembler symbols; putting at least one of these | |
442 | between the name and the number will suffice. | |
443 | ||
444 | If this macro is not defined, a default definition will be provided | |
445 | which is correct for most systems. | |
446 | ||
447 | .. c:macro:: ASM_OUTPUT_DEF (stream, name, value) | |
448 | ||
449 | A C statement to output to the stdio stream :samp:`{stream}` assembler code | |
450 | which defines (equates) the symbol :samp:`{name}` to have the value :samp:`{value}`. | |
451 | ||
452 | .. index:: SET_ASM_OP | |
453 | ||
454 | If ``SET_ASM_OP`` is defined, a default definition is provided which is | |
455 | correct for most systems. | |
456 | ||
457 | .. c:macro:: ASM_OUTPUT_DEF_FROM_DECLS (stream, decl_of_name, decl_of_value) | |
458 | ||
459 | A C statement to output to the stdio stream :samp:`{stream}` assembler code | |
460 | which defines (equates) the symbol whose tree node is :samp:`{decl_of_name}` | |
461 | to have the value of the tree node :samp:`{decl_of_value}`. This macro will | |
462 | be used in preference to :samp:`ASM_OUTPUT_DEF` if it is defined and if | |
463 | the tree nodes are available. | |
464 | ||
465 | .. index:: SET_ASM_OP | |
466 | ||
467 | If ``SET_ASM_OP`` is defined, a default definition is provided which is | |
468 | correct for most systems. | |
469 | ||
470 | .. c:macro:: TARGET_DEFERRED_OUTPUT_DEFS (decl_of_name, decl_of_value) | |
471 | ||
472 | A C statement that evaluates to true if the assembler code which defines | |
473 | (equates) the symbol whose tree node is :samp:`{decl_of_name}` to have the value | |
474 | of the tree node :samp:`{decl_of_value}` should be emitted near the end of the | |
475 | current compilation unit. The default is to not defer output of defines. | |
476 | This macro affects defines output by :samp:`ASM_OUTPUT_DEF` and | |
477 | :samp:`ASM_OUTPUT_DEF_FROM_DECLS`. | |
478 | ||
479 | .. c:macro:: ASM_OUTPUT_WEAK_ALIAS (stream, name, value) | |
480 | ||
481 | A C statement to output to the stdio stream :samp:`{stream}` assembler code | |
482 | which defines (equates) the weak symbol :samp:`{name}` to have the value | |
483 | :samp:`{value}`. If :samp:`{value}` is ``NULL``, it defines :samp:`{name}` as | |
484 | an undefined weak symbol. | |
485 | ||
486 | Define this macro if the target only supports weak aliases; define | |
487 | ``ASM_OUTPUT_DEF`` instead if possible. | |
488 | ||
489 | .. c:macro:: OBJC_GEN_METHOD_LABEL (buf, is_inst, class_name, cat_name, sel_name) | |
490 | ||
491 | Define this macro to override the default assembler names used for | |
492 | Objective-C methods. | |
493 | ||
494 | The default name is a unique method number followed by the name of the | |
495 | class (e.g. :samp:`_1_Foo`). For methods in categories, the name of | |
496 | the category is also included in the assembler name (e.g. | |
497 | :samp:`_1_Foo_Bar`). | |
498 | ||
499 | These names are safe on most systems, but make debugging difficult since | |
500 | the method's selector is not present in the name. Therefore, particular | |
501 | systems define other ways of computing names. | |
502 | ||
503 | :samp:`{buf}` is an expression of type ``char *`` which gives you a | |
504 | buffer in which to store the name; its length is as long as | |
505 | :samp:`{class_name}`, :samp:`{cat_name}` and :samp:`{sel_name}` put together, plus | |
506 | 50 characters extra. | |
507 | ||
508 | The argument :samp:`{is_inst}` specifies whether the method is an instance | |
509 | method or a class method; :samp:`{class_name}` is the name of the class; | |
510 | :samp:`{cat_name}` is the name of the category (or ``NULL`` if the method is not | |
511 | in a category); and :samp:`{sel_name}` is the name of the selector. | |
512 | ||
513 | On systems where the assembler can handle quoted names, you can use this | |
3ed1b4ce | 514 | macro to provide more human-readable names. |