DWARF Standard


090107.1 Kendrick Wong Support C++0x generalized constant expression - user-defined literal Enhancement Accepted Kendrick Wong


C++0x generalizes the notion of constant expressions to include
constant expression functions and user-defined literals.
For detail description of the feature, please refer to:


The new keyword constexpr allows the user to guarantee 
that a data, function or object constructor is a compile-time 
constant.  Standard allows floating-point constant expression 
as well. The constexpr is a new declaration specifier 
(not a new type) and it does not affect overloading rules.  A 
variable or datamember declared with constexpr behaves 
as if it was declared with const. Constant expression 
function must be defined before it is used, thus disallowing 
recursive function calls. Function parameter cannot be declared
constexpr. A constant-expression function may be called
with non-constant expressions, in that case there is no 
requirement that the resulting value be evaluated at compile-time. 
A function or a constructor declared with constexpr is
implicitly inline. A constant-expression constructor may be invoked 
with non-constant expression arguments, the resulting initialization
may then be dynamic.

  constexpr int Five = 5;               // constant-expression data
  constexpr int GetFive() {return 5;}   // constant-expression function
  struct integer {
    constexpr integer (int a) : v(a) { }
    constexpr int val() { return v; }
    int v;
  constexpr integer numFive(5);         // constant-expression constructor
                                        // or user-defined literal

  //create an array of 15 integers.
  int some_value[Five+GetFive()+numFive.val()];

Proposed Changes to the DWARF Specification

* To identify if a variable, function or object constructor can be 
  evaluated as compile-time constants.
* (Optional) To capture the value of the constant-expression.

New DWARF attribute:
|DW_AT_const_expr | 0x69 | flag | A compile-time constant expression | Abstract Instances

In C++, a function or a constructor declared with constexpr is 
implicitly inline. This abstract inline instance is represented by 
a debugging information entry with the tag DW_TAG_subprogram. Such 
entry has a DW_AT_inline attribute whose value is DW_INL_inlined. Concrete Inlined Instances

Each inline subroutine entry may contain a DW_AT_const_expr attribute 
whose value is a flag which indicates that the subroutine can be 
evaluated as a compile-time constant. Such entries may have a 
DW_AT_const_value attribute, whose value may be a string or any of 
the constant data or data block forms, as appropriate for the 
representation of the subroutine's return value. The value of this 
attribute is the actual return value of the subroutine, represented
as it would be on the target architecture.

In C++, if a function or a constructor declared with constexpr 
is called with constant-expressions, then this concrete inlined 
instance has a DW_AT_const_expr attribute, as well as a DW_AT_const_value 
attribute, whose value represent the actual return value of the 
concrete inline instance. Such entry also have DW_AT_call_file, 
DW_AT_call_line and DW_AT_call_col, indicating where the subroutine 
is called.

4.1: Data Object Entries

An entry describing a variable may have a DW_AT_const_expr attribute,
 whose value is a flag which indicate that the variable can be evaluated 
as a compile-time constant.

In C++, a variable declared with constexpr is implicitly const. Such 
variable has a DW_AT_type attribute, whose value is a reference to a 
debugging information entry describing a const qualified type.

constexpr double mass = 9.8;

<1><  xxx>      DW_TAG_base_type
                DW_AT_name                  double
                DW_AT_encoding              DW_ATE_float
<1><  yyy>      DW_TAG_const_type
                DW_AT_type                  <xxx>
<1><  yyy>      DW_TAG_variable
                DW_AT_name                  mass
                DW_AT_type                  <yyy>
                DW_AT_const_expr            yes
                DW_AT_const_value           9.8

constexpr int square (int x) { return x * x; }

float array[square(9)];           // square() called at line 3, column 12
extern const in medium;
const int high = square(medium);  // high is NOT a constant expression

<1><  xxx>      DW_TAG_base_type
                DW_AT_name                  int
                DW_AT_encoding              DW_ATE_signed

! abstract instance
<1><  yyy>      DW_TAG_subprogram
                DW_AT_name                  square
                DW_AT_type                  <xxx>
                DW_AT_inline                DW_INL_inlined
<2><  zzz>      DW_TAG_formal_parameter
                DW_AT_name                  x
                DW_AT_type                  <xxx>
! concrete instance for square(9)
<1><  ...>      DW_TAG_inlined_subroutine
                DW_AT_abstract_origin       <yyy>
                DW_AT_const_expr            yes
                DW_AT_const_value           81
                DW_AT_call_file             1
                DW_AT_call_line             3
                DW_AT_call_column           12
<2><  ...>      DW_TAG_formal_parameter
                DW_AT_abstract_origin       <zzz>
                DW_AT_const_value           9

! concrete instance for non constant-expression version of square()
<1><  ...>      DW_TAG_inlined_subroutine
                DW_AT_abstract_origin       <yyy>
                DW_AT_low_pc                ...
                DW_AT_high_pc               ...
<2><  ...>      DW_TAG_formal_parameter
                DW_AT_abstract_origin       <zzz>
                DW_AT_location              ...

Revised March 17, 2009 -- Add non-normative text describing C++ usage.



All logos and trademarks in this site are property of their respective owner.
The comments are property of their posters, all the rest © 2007-2017 by DWARF Standards Committee.