xref: /freebsd-11.0-release/contrib/gcc/cp/cp-tree.def

/* This file contains the definitions and documentation for the
   additional tree codes used in the GNU C++ compiler (see tree.def
   for the standard codes).
   Copyright (C) 1987, 1988, 1990, 1993, 1997, 1998, 2003, 
   1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   Hacked by Michael Tiemann (tiemann@cygnus.com)

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

 
/* An OFFSET_REF is used in two situations:

   1. An expression of the form `A::m' where `A' is a class and `m' is
      a non-static member.  In this case, operand 0 will be a TYPE
      (corresponding to `A') and operand 1 will be a FIELD_DECL,
      BASELINK, or TEMPLATE_ID_EXPR (corresponding to `m').

      The expression is a pointer-to-member if its address is taken,
      but simply denotes a member of the object if its address isnot
      taken.  In the latter case, resolve_offset_ref is used to
      convert it to a representation of the member referred to by the
      OFFSET_REF.
      
      This form is only used during the parsing phase; once semantic
      analysis has taken place they are eliminated.

   2. An expression of the form `x.*p'.  In this case, operand 0 will
      be an expression corresponding to `x' and operand 1 will be an
      expression with pointer-to-member type.  */
DEFTREECODE (OFFSET_REF, "offset_ref", 'r', 2)

/* A pointer-to-member constant.  For a pointer-to-member constant
   `X::Y' The PTRMEM_CST_CLASS is the RECORD_TYPE for `X' and the
   PTRMEM_CST_MEMBER is the _DECL for `Y'.  */
DEFTREECODE (PTRMEM_CST, "ptrmem_cst", 'c', 0)

/* For NEW_EXPR, operand 0 is the placement list.
   Operand 1 is the new-declarator.
   Operand 2 is the initializer.  */
DEFTREECODE (NEW_EXPR, "nw_expr", 'e', 3)
DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", 'e', 3)

/* For DELETE_EXPR, operand 0 is the store to be destroyed.
   Operand 1 is the value to pass to the destroying function
   saying whether the store should be deallocated as well.  */
DEFTREECODE (DELETE_EXPR, "dl_expr", 'e', 2)
DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", 'e', 2)

/* Value is reference to particular overloaded class method.
   Operand 0 is the class, operand 1 is the field
   The COMPLEXITY field holds the class level (usually 0).  */
DEFTREECODE (SCOPE_REF, "scope_ref", 'r', 2)

/* When composing an object with a member, this is the result.
   Operand 0 is the object.  Operand 1 is the member (usually
   a dereferenced pointer to member).  */
DEFTREECODE (MEMBER_REF, "member_ref", 'r', 2)

/* Type conversion operator in C++.  TREE_TYPE is type that this
   operator converts to.  Operand is expression to be converted.  */
DEFTREECODE (TYPE_EXPR, "type_expr", 'e', 1)

/* For AGGR_INIT_EXPR, operand 0 is function which performs initialization,
   operand 1 is argument list to initialization function,
   and operand 2 is the slot which was allocated for this expression.  */
DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", 'e', 3)

/* A throw expression.  operand 0 is the expression, if there was one,
   else it is NULL_TREE.  */
DEFTREECODE (THROW_EXPR, "throw_expr", 'e', 1)

/* An empty class object.  The TREE_TYPE gives the class type.  We use
   these to avoid actually creating instances of the empty classes.  */
DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", 'e', 0)

/* A DECL which is really just a placeholder for an expression.  Used to
   implement non-class scope anonymous unions.  */
DEFTREECODE (ALIAS_DECL, "alias_decl", 'd', 0)

/* A reference to a member function or member functions from a base
   class.  BASELINK_FUNCTIONS gives the FUNCTION_DECL,
   TEMPLATE_DECL, OVERLOAD, or TEMPLATE_ID_EXPR corresponding to the
   functions.  BASELINK_BINFO gives the base from which the functions
   come, i.e., the base to which the `this' pointer must be converted
   before the functions are called.  BASELINK_ACCESS_BINFO gives the
   base used to name the functions.  

   A BASELINK is an expression; the TREE_TYPE of the BASELINK gives
   the type of the expression.  This type is either a FUNCTION_TYPE,
   METHOD_TYPE, or `unknown_type_node' indicating that the function is
   overloaded. */
DEFTREECODE (BASELINK, "baselink", 'x', 0)

/* Template definition.  The following fields have the specified uses,
   although there are other macros in cp-tree.h that should be used for
   accessing this data.
        DECL_ARGUMENTS          template parm vector
        DECL_TEMPLATE_INFO      template text &c
	DECL_VINDEX		list of instantiations already produced;
				only done for functions so far
   For class template:
        DECL_INITIAL            associated templates (methods &c)
        DECL_TEMPLATE_RESULT    null
   For non-class templates:
	TREE_TYPE		type of object to be constructed
        DECL_TEMPLATE_RESULT    decl for object to be created
                                (e.g., FUNCTION_DECL with tmpl parms used)
 */
DEFTREECODE (TEMPLATE_DECL, "template_decl", 'd', 0)

/* Index into a template parameter list.  The TEMPLATE_PARM_IDX gives
   the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL
   gives the level (from 1) of the parameter.

   Here's an example:
   
   template <class T> // Index 0, Level 1.
   struct S
   {
      template <class U, // Index 0, Level 2.
                class V> // Index 1, Level 2.
      void f();
   };  

   The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended
   from this one.  The first descendant will have the same IDX, but
   its LEVEL will be one less.  The TREE_CHAIN field is used to chain
   together the descendants.  The TEMPLATE_PARM_DECL is the
   declaration of this parameter, either a TYPE_DECL or CONST_DECL.
   The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant
   parent, i.e., the LEVEL that the parameter originally had when it
   was declared.  For example, if we instantiate S<int>, we will have:

   struct S<int>
   {
     template <class U, // Index 0, Level 1, Orig Level 2
               class V> // Index 1, Level 1, Orig Level 2
     void f();
   };
  
   The LEVEL is the level of the parameter when we are worrying about
   the types of things; the ORIG_LEVEL is the level when we are
   worrying about instantiating things.  */
DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", 'x', 0)

/* Index into a template parameter list.  This parameter must be a type.
   The TYPE_FIELDS value will be a TEMPLATE_PARM_INDEX.  */
DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", 't', 0)

/* Index into a template parameter list for template template parameters.
   This parameter must be a type.  The TYPE_FIELDS value will be a 
   TEMPLATE_PARM_INDEX.

   It is used without template arguments like TT in C<TT>, 
   TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE
   and TYPE_NAME is a TEMPLATE_DECL.  */
DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", 't', 0)

/* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments 
   like TT<int>.
   In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
   template name and its bound arguments.  TYPE_NAME is a TYPE_DECL.  */
DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm", 't', 0)

/* A type designated by `typename T::t'.  TYPE_CONTEXT is `T',
   TYPE_NAME is an IDENTIFIER_NODE for `t'.  If the type was named via
   template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.
   If TREE_TYPE is present, this type was generated by the implicit
   typename extension, and the TREE_TYPE is a _TYPE from a baseclass
   of `T'.  */
DEFTREECODE (TYPENAME_TYPE, "typename_type", 't', 0)

/* For template template argument of the form `T::template C'.
   TYPE_CONTEXT is `T', the template parameter dependent object.
   TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template.  */
DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", 't', 0)

/* A type designated by `__typeof (expr)'.  TYPE_FIELDS is the
   expression in question.  */
DEFTREECODE (TYPEOF_TYPE, "typeof_type", 't', 0)

/* A using declaration.  DECL_INITIAL contains the specified scope.  
   This is not an alias, but is later expanded into multiple aliases.
   The decl will have a NULL_TYPE iff the scope is a dependent scope,
   otherwise it will have a void type. */
DEFTREECODE (USING_DECL, "using_decl", 'd', 0)

/* A using directive. The operand is USING_STMT_NAMESPACE. */     
DEFTREECODE (USING_STMT, "using_directive", 'e', 1)

/* An un-parsed default argument.  Looks like an IDENTIFIER_NODE.  */
DEFTREECODE (DEFAULT_ARG, "default_arg", 'x', 0)

/* A template-id, like foo<int>.  The first operand is the template.
   The second is NULL if there are no explicit arguments, or a
   TREE_VEC of arguments.  The template will be a FUNCTION_DECL,
   TEMPLATE_DECL, or an OVERLOAD.  If the template-id refers to a
   member template, the template may be an IDENTIFIER_NODE.  */
DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", 'e', 2)

/* A list-like node for chaining overloading candidates. TREE_TYPE is 
   the original name, and the parameter is the FUNCTION_DECL.  */
DEFTREECODE (OVERLOAD, "overload", 'x', 0)

/* A generic wrapper for something not tree that we want to include in
   tree structure.  */
DEFTREECODE (WRAPPER, "wrapper", 'x', 0)

/* A whole bunch of tree codes for the initial, superficial parsing of
   templates.  */
DEFTREECODE (MODOP_EXPR, "modop_expr", 'e', 3)
DEFTREECODE (CAST_EXPR, "cast_expr", '1', 1)
DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", '1', 1)
DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", '1', 1)
DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", '1', 1)
DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", '1', 1)
DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", 'e', 2)
DEFTREECODE (TYPEID_EXPR, "typeid_expr", 'e', 1)
DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", 'e', 3)

/* A placeholder for an expression that is not type-dependent, but
   does occur in a template.  When an expression that is not
   type-dependent appears in a larger expression, we must compute the
   type of that larger expression.  That computation would normally
   modify the original expression, which would change the mangling of
   that expression if it appeared in a template argument list.  In
   that situation, we create a NON_DEPENDENT_EXPR to take the place of
   the original expression.  The expression is the only operand -- it
   is only needed for diagnostics.   */
DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", 'e', 1)

/* CTOR_INITIALIZER is a placeholder in template code for a call to
   setup_vtbl_pointer (and appears in all functions, not just ctors).  */
DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", 'e', 1)
DEFTREECODE (TRY_BLOCK, "try_block", 'e', 2)
DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", 'e', 2)
/* A HANDLER wraps a catch handler for the HANDLER_TYPE.  If this is
   CATCH_ALL_TYPE, then the handler catches all types.  The declaration of
   the catch variable is in HANDLER_PARMS, and the body block in
   HANDLER_BODY.  */
DEFTREECODE (HANDLER, "handler", 'e', 2)

/* A MUST_NOT_THROW_EXPR wraps an expression that may not
   throw, and must call terminate if it does.  */
DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", 'e', 1)

DEFTREECODE (TAG_DEFN, "tag_defn", 'e', 0)

/* The following codes are used to represent implicit conversion
   sequences, in the sense of [over.best.ics].  The conversion
   sequences are connected through their first operands, with the
   first conversion to be performed at the end of the chain.

   The innermost conversion (i.e, the one at the end of the chain) is
   always an IDENTITY_CONV, corresponding to the identity conversion.  */

DEFTREECODE (IDENTITY_CONV, "identity_conv", 'e', 1)
DEFTREECODE (LVALUE_CONV, "lvalue_conv", 'e', 1)
DEFTREECODE (QUAL_CONV, "qual_conv", 'e', 1)
DEFTREECODE (STD_CONV, "std_conv", 'e', 1)
DEFTREECODE (PTR_CONV, "ptr_conv", 'e', 1)
DEFTREECODE (PMEM_CONV, "pmem_conv", 'e', 1)
DEFTREECODE (BASE_CONV, "base_conv", 'e', 1)
DEFTREECODE (REF_BIND, "ref_bind", 'e', 1)
DEFTREECODE (USER_CONV, "user_conv", 'e', 2)
DEFTREECODE (AMBIG_CONV, "ambig_conv", 'e', 1)
DEFTREECODE (RVALUE_CONV, "rvalue_conv", 'e', 1)

/*
Local variables:
mode:c
End:
*/