[thirdparty/gcc.git] /

..
  Copyright 1988-2022 Free Software Foundation, Inc.
  This is part of the GCC manual.
  For copying conditions, see the copyright.rst file.

.. _label-output:

Output and Generation of Labels
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

.. prevent bad page break with this line

This is about outputting labels.

.. index:: assemble_name

.. c:macro:: ASM_OUTPUT_LABEL (stream, name)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` the assembler definition of a label named :samp:`{name}`.
  Use the expression ``assemble_name (stream, name)`` to
  output the name itself; before and after that, output the additional
  assembler syntax for defining the name, and a newline.  A default
  definition of this macro is provided which is correct for most systems.

.. c:macro:: ASM_OUTPUT_FUNCTION_LABEL (stream, name, decl)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` the assembler definition of a label named :samp:`{name}` of
  a function.
  Use the expression ``assemble_name (stream, name)`` to
  output the name itself; before and after that, output the additional
  assembler syntax for defining the name, and a newline.  A default
  definition of this macro is provided which is correct for most systems.

  If this macro is not defined, then the function name is defined in the
  usual manner as a label (by means of ``ASM_OUTPUT_LABEL``).

.. index:: assemble_name_raw

.. c:macro:: ASM_OUTPUT_INTERNAL_LABEL (stream, name)

  Identical to ``ASM_OUTPUT_LABEL``, except that :samp:`{name}` is known
  to refer to a compiler-generated label.  The default definition uses
  ``assemble_name_raw``, which is like ``assemble_name`` except
  that it is more efficient.

.. c:macro:: SIZE_ASM_OP

  A C string containing the appropriate assembler directive to specify the
  size of a symbol, without any arguments.  On systems that use ELF, the
  default (in :samp:`config/elfos.h`) is :samp:`"\\t.size\\t"`; on other
  systems, the default is not to define this macro.

  Define this macro only if it is correct to use the default definitions
  of ``ASM_OUTPUT_SIZE_DIRECTIVE`` and ``ASM_OUTPUT_MEASURED_SIZE``
  for your system.  If you need your own custom definitions of those
  macros, or if you do not need explicit symbol sizes at all, do not
  define this macro.

.. c:macro:: ASM_OUTPUT_SIZE_DIRECTIVE (stream, name, size)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` a directive telling the assembler that the size of the
  symbol :samp:`{name}` is :samp:`{size}`.  :samp:`{size}` is a ``HOST_WIDE_INT``.
  If you define ``SIZE_ASM_OP``, a default definition of this macro is
  provided.

.. c:macro:: ASM_OUTPUT_MEASURED_SIZE (stream, name)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` a directive telling the assembler to calculate the size of
  the symbol :samp:`{name}` by subtracting its address from the current
  address.

  If you define ``SIZE_ASM_OP``, a default definition of this macro is
  provided.  The default assumes that the assembler recognizes a special
  :samp:`.` symbol as referring to the current address, and can calculate
  the difference between this and another symbol.  If your assembler does
  not recognize :samp:`.` or cannot do calculations with it, you will need
  to redefine ``ASM_OUTPUT_MEASURED_SIZE`` to use some other technique.

.. c:macro:: NO_DOLLAR_IN_LABEL

  Define this macro if the assembler does not accept the character
  :samp:`$` in label names.  By default constructors and destructors in
  G++ have :samp:`$` in the identifiers.  If this macro is defined,
  :samp:`.` is used instead.

.. c:macro:: NO_DOT_IN_LABEL

  Define this macro if the assembler does not accept the character
  :samp:`.` in label names.  By default constructors and destructors in G++
  have names that use :samp:`.`.  If this macro is defined, these names
  are rewritten to avoid :samp:`.`.

.. c:macro:: TYPE_ASM_OP

  A C string containing the appropriate assembler directive to specify the
  type of a symbol, without any arguments.  On systems that use ELF, the
  default (in :samp:`config/elfos.h`) is :samp:`"\\t.type\\t"`; on other
  systems, the default is not to define this macro.

  Define this macro only if it is correct to use the default definition of
  ``ASM_OUTPUT_TYPE_DIRECTIVE`` for your system.  If you need your own
  custom definition of this macro, or if you do not need explicit symbol
  types at all, do not define this macro.

.. c:macro:: TYPE_OPERAND_FMT

  A C string which specifies (using ``printf`` syntax) the format of
  the second operand to ``TYPE_ASM_OP``.  On systems that use ELF, the
  default (in :samp:`config/elfos.h`) is :samp:`"@%s"`; on other systems,
  the default is not to define this macro.

  Define this macro only if it is correct to use the default definition of
  ``ASM_OUTPUT_TYPE_DIRECTIVE`` for your system.  If you need your own
  custom definition of this macro, or if you do not need explicit symbol
  types at all, do not define this macro.

.. c:macro:: ASM_OUTPUT_TYPE_DIRECTIVE (stream, type)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` a directive telling the assembler that the type of the
  symbol :samp:`{name}` is :samp:`{type}`.  :samp:`{type}` is a C string; currently,
  that string is always either :samp:`"function"` or :samp:`"object"`, but
  you should not count on this.

  If you define ``TYPE_ASM_OP`` and ``TYPE_OPERAND_FMT``, a default
  definition of this macro is provided.

.. c:macro:: ASM_DECLARE_FUNCTION_NAME (stream, name, decl)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` any text necessary for declaring the name :samp:`{name}` of a
  function which is being defined.  This macro is responsible for
  outputting the label definition (perhaps using
  ``ASM_OUTPUT_FUNCTION_LABEL``).  The argument :samp:`{decl}` is the
  ``FUNCTION_DECL`` tree node representing the function.

  If this macro is not defined, then the function name is defined in the
  usual manner as a label (by means of ``ASM_OUTPUT_FUNCTION_LABEL``).

  You may wish to use ``ASM_OUTPUT_TYPE_DIRECTIVE`` in the definition
  of this macro.

.. c:macro:: ASM_DECLARE_FUNCTION_SIZE (stream, name, decl)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` any text necessary for declaring the size of a function
  which is being defined.  The argument :samp:`{name}` is the name of the
  function.  The argument :samp:`{decl}` is the ``FUNCTION_DECL`` tree node
  representing the function.

  If this macro is not defined, then the function size is not defined.

  You may wish to use ``ASM_OUTPUT_MEASURED_SIZE`` in the definition
  of this macro.

.. c:macro:: ASM_DECLARE_COLD_FUNCTION_NAME (stream, name, decl)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` any text necessary for declaring the name :samp:`{name}` of a
  cold function partition which is being defined.  This macro is responsible
  for outputting the label definition (perhaps using
  ``ASM_OUTPUT_FUNCTION_LABEL``).  The argument :samp:`{decl}` is the
  ``FUNCTION_DECL`` tree node representing the function.

  If this macro is not defined, then the cold partition name is defined in the
  usual manner as a label (by means of ``ASM_OUTPUT_LABEL``).

  You may wish to use ``ASM_OUTPUT_TYPE_DIRECTIVE`` in the definition
  of this macro.

.. c:macro:: ASM_DECLARE_COLD_FUNCTION_SIZE (stream, name, decl)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` any text necessary for declaring the size of a cold function
  partition which is being defined.  The argument :samp:`{name}` is the name of the
  cold partition of the function.  The argument :samp:`{decl}` is the
  ``FUNCTION_DECL`` tree node representing the function.

  If this macro is not defined, then the partition size is not defined.

  You may wish to use ``ASM_OUTPUT_MEASURED_SIZE`` in the definition
  of this macro.

.. c:macro:: ASM_DECLARE_OBJECT_NAME (stream, name, decl)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` any text necessary for declaring the name :samp:`{name}` of an
  initialized variable which is being defined.  This macro must output the
  label definition (perhaps using ``ASM_OUTPUT_LABEL``).  The argument
  :samp:`{decl}` is the ``VAR_DECL`` tree node representing the variable.

  If this macro is not defined, then the variable name is defined in the
  usual manner as a label (by means of ``ASM_OUTPUT_LABEL``).

  You may wish to use ``ASM_OUTPUT_TYPE_DIRECTIVE`` and/or
  ``ASM_OUTPUT_SIZE_DIRECTIVE`` in the definition of this macro.

.. function:: void TARGET_ASM_DECLARE_CONSTANT_NAME (FILE *file, const char *name, const_tree expr, HOST_WIDE_INT size)

  .. hook-start:TARGET_ASM_DECLARE_CONSTANT_NAME

  A target hook to output to the stdio stream :samp:`{file}` any text necessary
  for declaring the name :samp:`{name}` of a constant which is being defined.  This
  target hook is responsible for outputting the label definition (perhaps using
  ``assemble_label``).  The argument :samp:`{exp}` is the value of the constant,
  and :samp:`{size}` is the size of the constant in bytes.  The :samp:`{name}`
  will be an internal label.

  The default version of this target hook, define the :samp:`{name}` in the
  usual manner as a label (by means of ``assemble_label``).

  You may wish to use ``ASM_OUTPUT_TYPE_DIRECTIVE`` in this target hook.

.. hook-end

.. c:macro:: ASM_DECLARE_REGISTER_GLOBAL (stream, decl, regno, name)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` any text necessary for claiming a register :samp:`{regno}`
  for a global variable :samp:`{decl}` with name :samp:`{name}`.

  If you don't define this macro, that is equivalent to defining it to do
  nothing.

.. c:macro:: ASM_FINISH_DECLARE_OBJECT (stream, decl, toplevel, atend)

  A C statement (sans semicolon) to finish up declaring a variable name
  once the compiler has processed its initializer fully and thus has had a
  chance to determine the size of an array when controlled by an
  initializer.  This is used on systems where it's necessary to declare
  something about the size of the object.

  If you don't define this macro, that is equivalent to defining it to do
  nothing.

  You may wish to use ``ASM_OUTPUT_SIZE_DIRECTIVE`` and/or
  ``ASM_OUTPUT_MEASURED_SIZE`` in the definition of this macro.

.. function:: void TARGET_ASM_GLOBALIZE_LABEL (FILE *stream, const char *name)

  .. hook-start:TARGET_ASM_GLOBALIZE_LABEL

  This target hook is a function to output to the stdio stream
  :samp:`{stream}` some commands that will make the label :samp:`{name}` global;
  that is, available for reference from other files.

  The default implementation relies on a proper definition of
  ``GLOBAL_ASM_OP``.

.. hook-end

.. function:: void TARGET_ASM_GLOBALIZE_DECL_NAME (FILE *stream, tree decl)

  .. hook-start:TARGET_ASM_GLOBALIZE_DECL_NAME

  This target hook is a function to output to the stdio stream
  :samp:`{stream}` some commands that will make the name associated with :samp:`{decl}`
  global; that is, available for reference from other files.

  The default implementation uses the TARGET_ASM_GLOBALIZE_LABEL target hook.

.. hook-end

.. function:: void TARGET_ASM_ASSEMBLE_UNDEFINED_DECL (FILE *stream, const char *name, const_tree decl)

  .. hook-start:TARGET_ASM_ASSEMBLE_UNDEFINED_DECL

  This target hook is a function to output to the stdio stream
  :samp:`{stream}` some commands that will declare the name associated with
  :samp:`{decl}` which is not defined in the current translation unit.  Most
  assemblers do not require anything to be output in this case.

.. hook-end

.. c:macro:: ASM_WEAKEN_LABEL (stream, name)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` some commands that will make the label :samp:`{name}` weak;
  that is, available for reference from other files but only used if
  no other definition is available.  Use the expression
  ``assemble_name (stream, name)`` to output the name
  itself; before and after that, output the additional assembler syntax
  for making that name weak, and a newline.

  If you don't define this macro or ``ASM_WEAKEN_DECL``, GCC will not
  support weak symbols and you should not define the ``SUPPORTS_WEAK``
  macro.

.. c:macro:: ASM_WEAKEN_DECL (stream, decl, name, value)

  Combines (and replaces) the function of ``ASM_WEAKEN_LABEL`` and
  ``ASM_OUTPUT_WEAK_ALIAS``, allowing access to the associated function
  or variable decl.  If :samp:`{value}` is not ``NULL``, this C statement
  should output to the stdio stream :samp:`{stream}` assembler code which
  defines (equates) the weak symbol :samp:`{name}` to have the value
  :samp:`{value}`.  If :samp:`{value}` is ``NULL``, it should output commands
  to make :samp:`{name}` weak.

.. c:macro:: ASM_OUTPUT_WEAKREF (stream, decl, name, value)

  Outputs a directive that enables :samp:`{name}` to be used to refer to
  symbol :samp:`{value}` with weak-symbol semantics.  ``decl`` is the
  declaration of ``name``.

.. c:macro:: SUPPORTS_WEAK

  A preprocessor constant expression which evaluates to true if the target
  supports weak symbols.

  If you don't define this macro, :samp:`defaults.h` provides a default
  definition.  If either ``ASM_WEAKEN_LABEL`` or ``ASM_WEAKEN_DECL``
  is defined, the default definition is :samp:`1`; otherwise, it is :samp:`0`.

.. c:macro:: TARGET_SUPPORTS_WEAK

  A C expression which evaluates to true if the target supports weak symbols.

  If you don't define this macro, :samp:`defaults.h` provides a default
  definition.  The default definition is :samp:`(SUPPORTS_WEAK)`.  Define
  this macro if you want to control weak symbol support with a compiler
  flag such as :option:`-melf`.

.. c:macro:: MAKE_DECL_ONE_ONLY (decl)

  A C statement (sans semicolon) to mark :samp:`{decl}` to be emitted as a
  public symbol such that extra copies in multiple translation units will
  be discarded by the linker.  Define this macro if your object file
  format provides support for this concept, such as the :samp:`COMDAT`
  section flags in the Microsoft Windows PE/COFF format, and this support
  requires changes to :samp:`{decl}`, such as putting it in a separate section.

.. c:macro:: SUPPORTS_ONE_ONLY

  A C expression which evaluates to true if the target supports one-only
  semantics.

  If you don't define this macro, :samp:`varasm.cc` provides a default
  definition.  If ``MAKE_DECL_ONE_ONLY`` is defined, the default
  definition is :samp:`1`; otherwise, it is :samp:`0`.  Define this macro if
  you want to control one-only symbol support with a compiler flag, or if
  setting the ``DECL_ONE_ONLY`` flag is enough to mark a declaration to
  be emitted as one-only.

.. function:: void TARGET_ASM_ASSEMBLE_VISIBILITY (tree decl, int visibility)

  .. hook-start:TARGET_ASM_ASSEMBLE_VISIBILITY

  This target hook is a function to output to :samp:`{asm_out_file}` some
  commands that will make the symbol(s) associated with :samp:`{decl}` have
  hidden, protected or internal visibility as specified by :samp:`{visibility}`.

.. hook-end

.. c:macro:: TARGET_WEAK_NOT_IN_ARCHIVE_TOC

  A C expression that evaluates to true if the target's linker expects
  that weak symbols do not appear in a static archive's table of contents.
  The default is ``0``.

  Leaving weak symbols out of an archive's table of contents means that,
  if a symbol will only have a definition in one translation unit and
  will have undefined references from other translation units, that
  symbol should not be weak.  Defining this macro to be nonzero will
  thus have the effect that certain symbols that would normally be weak
  (explicit template instantiations, and vtables for polymorphic classes
  with noninline key methods) will instead be nonweak.

  The C++ ABI requires this macro to be zero.  Define this macro for
  targets where full C++ ABI compliance is impossible and where linker
  restrictions require weak symbols to be left out of a static archive's
  table of contents.

.. c:macro:: ASM_OUTPUT_EXTERNAL (stream, decl, name)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` any text necessary for declaring the name of an external
  symbol named :samp:`{name}` which is referenced in this compilation but
  not defined.  The value of :samp:`{decl}` is the tree node for the
  declaration.

  This macro need not be defined if it does not need to output anything.
  The GNU assembler and most Unix assemblers don't require anything.

.. function:: void TARGET_ASM_EXTERNAL_LIBCALL (rtx symref)

  .. hook-start:TARGET_ASM_EXTERNAL_LIBCALL

  This target hook is a function to output to :samp:`{asm_out_file}` an assembler
  pseudo-op to declare a library function name external.  The name of the
  library function is given by :samp:`{symref}`, which is a ``symbol_ref``.

.. hook-end

.. function:: void TARGET_ASM_MARK_DECL_PRESERVED (const char *symbol)

  .. hook-start:TARGET_ASM_MARK_DECL_PRESERVED

  This target hook is a function to output to :samp:`{asm_out_file}` an assembler
  directive to annotate :samp:`{symbol}` as used.  The Darwin target uses the
  .no_dead_code_strip directive.

.. hook-end

.. c:macro:: ASM_OUTPUT_LABELREF (stream, name)

  A C statement (sans semicolon) to output to the stdio stream
  :samp:`{stream}` a reference in assembler syntax to a label named
  :samp:`{name}`.  This should add :samp:`_` to the front of the name, if that
  is customary on your operating system, as it is in most Berkeley Unix
  systems.  This macro is used in ``assemble_name``.

.. function:: tree TARGET_MANGLE_ASSEMBLER_NAME (const char *name)

  .. hook-start:TARGET_MANGLE_ASSEMBLER_NAME

  Given a symbol :samp:`{name}`, perform same mangling as ``varasm.cc`` 's
  ``assemble_name``, but in memory rather than to a file stream, returning
  result as an ``IDENTIFIER_NODE``.  Required for correct LTO symtabs.  The
  default implementation calls the ``TARGET_STRIP_NAME_ENCODING`` hook and
  then prepends the ``USER_LABEL_PREFIX``, if any.

.. hook-end

.. c:macro:: ASM_OUTPUT_SYMBOL_REF (stream, sym)

  A C statement (sans semicolon) to output a reference to
  ``SYMBOL_REF`` :samp:`{sym}`.  If not defined, ``assemble_name``
  will be used to output the name of the symbol.  This macro may be used
  to modify the way a symbol is referenced depending on information
  encoded by ``TARGET_ENCODE_SECTION_INFO``.

.. c:macro:: ASM_OUTPUT_LABEL_REF (stream, buf)

  A C statement (sans semicolon) to output a reference to :samp:`{buf}`, the
  result of ``ASM_GENERATE_INTERNAL_LABEL``.  If not defined,
  ``assemble_name`` will be used to output the name of the symbol.
  This macro is not used by ``output_asm_label``, or the ``%l``
  specifier that calls it; the intention is that this macro should be set
  when it is necessary to output a label differently when its address is
  being taken.

.. function:: void TARGET_ASM_INTERNAL_LABEL (FILE *stream, const char *prefix, unsigned long labelno)

  .. hook-start:TARGET_ASM_INTERNAL_LABEL

  A function to output to the stdio stream :samp:`{stream}` a label whose
  name is made from the string :samp:`{prefix}` and the number :samp:`{labelno}`.

  It is absolutely essential that these labels be distinct from the labels
  used for user-level functions and variables.  Otherwise, certain programs
  will have name conflicts with internal labels.

  It is desirable to exclude internal labels from the symbol table of the
  object file.  Most assemblers have a naming convention for labels that
  should be excluded; on many systems, the letter :samp:`L` at the
  beginning of a label has this effect.  You should find out what
  convention your system uses, and follow it.

  The default version of this function utilizes ``ASM_GENERATE_INTERNAL_LABEL``.

.. hook-end

.. c:macro:: ASM_OUTPUT_DEBUG_LABEL (stream, prefix, num)

  A C statement to output to the stdio stream :samp:`{stream}` a debug info
  label whose name is made from the string :samp:`{prefix}` and the number
  :samp:`{num}`.  This is useful for VLIW targets, where debug info labels
  may need to be treated differently than branch target labels.  On some
  systems, branch target labels must be at the beginning of instruction
  bundles, but debug info labels can occur in the middle of instruction
  bundles.

  If this macro is not defined, then ``(*targetm.asm_out.internal_label)`` will be
  used.

.. c:macro:: ASM_GENERATE_INTERNAL_LABEL (string, prefix, num)

  A C statement to store into the string :samp:`{string}` a label whose name
  is made from the string :samp:`{prefix}` and the number :samp:`{num}`.

  This string, when output subsequently by ``assemble_name``, should
  produce the output that ``(*targetm.asm_out.internal_label)`` would produce
  with the same :samp:`{prefix}` and :samp:`{num}`.

  If the string begins with :samp:`*`, then ``assemble_name`` will
  output the rest of the string unchanged.  It is often convenient for
  ``ASM_GENERATE_INTERNAL_LABEL`` to use :samp:`*` in this way.  If the
  string doesn't start with :samp:`*`, then ``ASM_OUTPUT_LABELREF`` gets
  to output the string, and may change it.  (Of course,
  ``ASM_OUTPUT_LABELREF`` is also part of your machine description, so
  you should know what it does on your machine.)

.. c:macro:: ASM_FORMAT_PRIVATE_NAME (outvar, name, number)

  A C expression to assign to :samp:`{outvar}` (which is a variable of type
  ``char *``) a newly allocated string made from the string
  :samp:`{name}` and the number :samp:`{number}`, with some suitable punctuation
  added.  Use ``alloca`` to get space for the string.

  The string will be used as an argument to ``ASM_OUTPUT_LABELREF`` to
  produce an assembler label for an internal static variable whose name is
  :samp:`{name}`.  Therefore, the string must be such as to result in valid
  assembler code.  The argument :samp:`{number}` is different each time this
  macro is executed; it prevents conflicts between similarly-named
  internal static variables in different scopes.

  Ideally this string should not be a valid C identifier, to prevent any
  conflict with the user's own symbols.  Most assemblers allow periods
  or percent signs in assembler symbols; putting at least one of these
  between the name and the number will suffice.

  If this macro is not defined, a default definition will be provided
  which is correct for most systems.

.. c:macro:: ASM_OUTPUT_DEF (stream, name, value)

  A C statement to output to the stdio stream :samp:`{stream}` assembler code
  which defines (equates) the symbol :samp:`{name}` to have the value :samp:`{value}`.

  .. index:: SET_ASM_OP

  If ``SET_ASM_OP`` is defined, a default definition is provided which is
  correct for most systems.

.. c:macro:: ASM_OUTPUT_DEF_FROM_DECLS (stream, decl_of_name, decl_of_value)

  A C statement to output to the stdio stream :samp:`{stream}` assembler code
  which defines (equates) the symbol whose tree node is :samp:`{decl_of_name}`
  to have the value of the tree node :samp:`{decl_of_value}`.  This macro will
  be used in preference to :samp:`ASM_OUTPUT_DEF` if it is defined and if
  the tree nodes are available.

  .. index:: SET_ASM_OP

  If ``SET_ASM_OP`` is defined, a default definition is provided which is
  correct for most systems.

.. c:macro:: TARGET_DEFERRED_OUTPUT_DEFS (decl_of_name, decl_of_value)

  A C statement that evaluates to true if the assembler code which defines
  (equates) the symbol whose tree node is :samp:`{decl_of_name}` to have the value
  of the tree node :samp:`{decl_of_value}` should be emitted near the end of the
  current compilation unit.  The default is to not defer output of defines.
  This macro affects defines output by :samp:`ASM_OUTPUT_DEF` and
  :samp:`ASM_OUTPUT_DEF_FROM_DECLS`.

.. c:macro:: ASM_OUTPUT_WEAK_ALIAS (stream, name, value)

  A C statement to output to the stdio stream :samp:`{stream}` assembler code
  which defines (equates) the weak symbol :samp:`{name}` to have the value
  :samp:`{value}`.  If :samp:`{value}` is ``NULL``, it defines :samp:`{name}` as
  an undefined weak symbol.

  Define this macro if the target only supports weak aliases; define
  ``ASM_OUTPUT_DEF`` instead if possible.

.. c:macro:: OBJC_GEN_METHOD_LABEL (buf, is_inst, class_name, cat_name, sel_name)

  Define this macro to override the default assembler names used for
  Objective-C methods.

  The default name is a unique method number followed by the name of the
  class (e.g. :samp:`_1_Foo`).  For methods in categories, the name of
  the category is also included in the assembler name (e.g.
  :samp:`_1_Foo_Bar`).

  These names are safe on most systems, but make debugging difficult since
  the method's selector is not present in the name.  Therefore, particular
  systems define other ways of computing names.

  :samp:`{buf}` is an expression of type ``char *`` which gives you a
  buffer in which to store the name; its length is as long as
  :samp:`{class_name}`, :samp:`{cat_name}` and :samp:`{sel_name}` put together, plus
  50 characters extra.

  The argument :samp:`{is_inst}` specifies whether the method is an instance
  method or a class method; :samp:`{class_name}` is the name of the class;
  :samp:`{cat_name}` is the name of the category (or ``NULL`` if the method is not
  in a category); and :samp:`{sel_name}` is the name of the selector.

  On systems where the assembler can handle quoted names, you can use this
  macro to provide more human-readable names.