Patchwork RFA: consolidate DWARF strings into libiberty

login
register
mail settings
Submitter Tom Tromey
Date March 15, 2012, 5:57 p.m.
Message ID <87k42lbvco.fsf@fleche.redhat.com>
Download mbox | patch
Permalink /patch/147053/
State New
Headers show

Comments

Tom Tromey - March 15, 2012, 5:57 p.m.
Please pardon the CCs.  This first patch isn't directly applicable to
all the projects, but if this is approved then I have follow-on patches
for gdb and binutils.

Right now if a new opcode (or some other constant) is added to dwarf2.h,
then various places must be updated: gcc, gdb, and binutils all have
copies of functions to convert, e.g. DW_OP constants to strings.

This is occasionally forgotten, e.g.:

    http://sourceware.org/ml/gdb-patches/2012-03/msg00521.html

... and even if not forgotten it is a pointless maintenance burden.

This patch consolidates all such functions into libiberty.
It also adds a "dwarf2.def" file that is the master source for these
constants, so that future changes are automatically reflected in the
string tables without extra effort.


A couple oddities about this patch, both needed to work around the use
of -pedantic in libiberty.

First, you'll notice that the first constant for a given enum is defined
using a separate macro name.  I couldn't think of a better way to avoid
the "trailing ',' in an enum" warning -- one element must be
distinguished, so I chose the first.

Also, you'll see that the names passed to the macros start with an "_".
This avoids a -Wc++-compat warning about the use of tokens like "and".

Built and regtested on x86-64 Fedora 16.

Ok?

Tom

2012-03-15  Tom Tromey  <tromey@redhat.com>

	* dwarf2out.c (dwarf_stack_op_name): Use get_DW_OP_name.
	(dwarf_tag_name): Use get_DW_TAG_name.
	(dwarf_attr_name): Use get_DW_AT_name.
	(dwarf_form_name): Use get_DW_FORM_name.
	* dwarf2cfi.c (dwarf_cfi_name): Use get_DW_CFA_name.

2012-03-15  Tom Tromey  <tromey@redhat.com>

	* dwarf2.h (enum dwarf_tag, enum dwarf_form, enum dwarf_attribute)
	(enum dwarf_location_atom, enum dwarf_type, enum
	dwarf_call_frame_info): Remove.
	(DW_TAG, DW_TAG_DUP, DW_FORM, DW_AT, DW_AT_DUP, DW_OP)
	(DW_OP_DUP, DW_ATE, DW_ATE_DUP, DW_CFA): New macros.
	Include dwarf2.def.
	(get_DW_TAG_name, get_DW_AT_name, get_DW_FORM_name)
	(get_DW_OP_name, get_DW_ATE_name): Declare.
	* dwarf2.def: New file, from dwarf2.h.

2012-03-15  Tom Tromey  <tromey@redhat.com>

	* dwarfnames.c: New file.
	* Makefile.in (CFILES): Add dwarfnames.
	(REQUIRED_OFILES): Add dwarfnames.
	(./dwarfnames.$(objext)): New target.
DJ Delorie - March 15, 2012, 6:33 p.m.
Sigh, libiberty is supposed to be a portability library, not a
kitchen-sink for common stuff.  Should I give up that premise?  Or
should we consider a common dwarf2 helper library, and move even more
of the dwarf2 code into it?

> First, you'll notice that the first constant for a given enum is
> defined using a separate macro name.  I couldn't think of a better
> way to avoid the "trailing ',' in an enum" warning -- one element
> must be distinguished, so I chose the first.

I typically terminate the list with a "FOO_MAX" enum, which is going
to need to be handled differently anyway.

> Also, you'll see that the names passed to the macros start with an "_".

Beware you're not violating (or causing to violate) some ISO namespace
requirement for identifiers starting with underscores.
Tom Tromey - March 15, 2012, 6:41 p.m.
>>>>> "DJ" == DJ Delorie <dj@redhat.com> writes:

DJ> Sigh, libiberty is supposed to be a portability library, not a
DJ> kitchen-sink for common stuff.  Should I give up that premise?  Or
DJ> should we consider a common dwarf2 helper library, and move even more
DJ> of the dwarf2 code into it?

My reasoning was:

I would have put it somewhere else, but there is nowhere else to put it.
Making a new library for this one file seemed like overkill.
Finally, there is already stuff in libiberty not related to
portability.  E.g., hashtab or the demangler.

Tom> First, you'll notice that the first constant for a given enum is
Tom> defined using a separate macro name.  I couldn't think of a better
Tom> way to avoid the "trailing ',' in an enum" warning -- one element
Tom> must be distinguished, so I chose the first.

DJ> I typically terminate the list with a "FOO_MAX" enum, which is going
DJ> to need to be handled differently anyway.

I usually do that to, but I wanted this change not to affect the
contents of the defined enums.

Tom> Also, you'll see that the names passed to the macros start with an "_".

DJ> Beware you're not violating (or causing to violate) some ISO namespace
DJ> requirement for identifiers starting with underscores.

Yeah, I didn't consider that.

I guess I can just put the whole DW_TAG_ prefix in there.
That isn't a big deal.  Or if you have some other suggestion, I can
implement it.

Tom
DJ Delorie - March 15, 2012, 6:48 p.m.
> Finally, there is already stuff in libiberty not related to
> portability.  E.g., hashtab or the demangler.

Yeah, I know, hence my "Should I give up that premise?"

> I guess I can just put the whole DW_TAG_ prefix in there.  That
> isn't a big deal.  Or if you have some other suggestion, I can
> implement it.

If the macros always prepend something to it, it should be safe
enough, despite technically violating the spirit of the rule.  I have
no other suggestions.

But given you've already had the issue with "and", you're already
seeing problems anyway, so maybe that's a sign that it's not actually
"safe enough" ?
Pedro Alves - March 15, 2012, 6:54 p.m.
On 03/15/2012 06:48 PM, DJ Delorie wrote:

>> Finally, there is already stuff in libiberty not related to
>> > portability.  E.g., hashtab or the demangler.
> Yeah, I know, hence my "Should I give up that premise?"

Wouldn't it make sense to eventually switch everything to gnulib
for portability instead?  With that in mind, I predict we'll end
up with libiberty composed of only the odd stuff.  :-)
Jakub Jelinek - March 15, 2012, 7:01 p.m.
On Thu, Mar 15, 2012 at 12:41:54PM -0600, Tom Tromey wrote:
> I guess I can just put the whole DW_TAG_ prefix in there.
> That isn't a big deal.  Or if you have some other suggestion, I can
> implement it.

Yeah, I think the either the whole OP_TAG (DW_TAG_foobar, ...), or
OP_TAG (TAG_foobar, ...) would be safer and nicer.

	Jakub
Tom Tromey - March 15, 2012, 7:02 p.m.
>>>>> "DJ" == DJ Delorie <dj@redhat.com> writes:

Tom> Finally, there is already stuff in libiberty not related to
Tom> portability.  E.g., hashtab or the demangler.

DJ> Yeah, I know, hence my "Should I give up that premise?"

Yeah.

I am not sure there will ever be enough shared code to warrant a new
library, particularly because adding a new library is so expensive --
not just the configury stuff but also adding it to the link lines in the
Makefiles of all the tools that might need it.

I suppose if I had my wish list implemented here, it would be to remove
the portability stuff from libiberty in favor of gnulib, and keep
libiberty as a higher-level library.

Tom> I guess I can just put the whole DW_TAG_ prefix in there.  That
Tom> isn't a big deal.  Or if you have some other suggestion, I can
Tom> implement it.

DJ> If the macros always prepend something to it, it should be safe
DJ> enough, despite technically violating the spirit of the rule.  I have
DJ> no other suggestions.

DJ> But given you've already had the issue with "and", you're already
DJ> seeing problems anyway, so maybe that's a sign that it's not actually
DJ> "safe enough" ?

I think this arises from a bug in cpp, since it issues the -Wc++-compat
warning even if the token in question is only used as an argument to
stringizing.  This seems mistaken -- but it seemed advisable to work
around it.

Tom
Tom Tromey - March 15, 2012, 7:04 p.m.
>>>>> "Jakub" == Jakub Jelinek <jakub@redhat.com> writes:

Jakub> On Thu, Mar 15, 2012 at 12:41:54PM -0600, Tom Tromey wrote:
>> I guess I can just put the whole DW_TAG_ prefix in there.
>> That isn't a big deal.  Or if you have some other suggestion, I can
>> implement it.

Jakub> Yeah, I think the either the whole OP_TAG (DW_TAG_foobar, ...), or
Jakub> OP_TAG (TAG_foobar, ...) would be safer and nicer.

Ok, no problem.  I will make that change.

Tom
Doug Evans - March 19, 2012, 4:09 p.m.
On Thu, Mar 15, 2012 at 12:02 PM, Tom Tromey <tromey@redhat.com> wrote:
>>>>>> "DJ" == DJ Delorie <dj@redhat.com> writes:
>
> Tom> Finally, there is already stuff in libiberty not related to
> Tom> portability.  E.g., hashtab or the demangler.
>
> DJ> Yeah, I know, hence my "Should I give up that premise?"
>
> Yeah.
>
> I am not sure there will ever be enough shared code to warrant a new
> library, particularly because adding a new library is so expensive --
> not just the configury stuff but also adding it to the link lines in the
> Makefiles of all the tools that might need it.
>
> I suppose if I had my wish list implemented here, it would be to remove
> the portability stuff from libiberty in favor of gnulib, and keep
> libiberty as a higher-level library.

That won't really fix libiberty being an ever growing kitchen sink.

How hard would it really be to make it easier to add new libraries?
It's not like we're expecting 100.
But given the pushback for even one new library, I think we're
unnecessarily slowing ourselves down.
DJ Delorie - March 19, 2012, 4:13 p.m.
> But given the pushback for even one new library, I think we're
> unnecessarily slowing ourselves down.

I'm not opposed to libiberty becoming the kitchen sink, if that's what
people want.  If it does go that route, my reason for being a
libiberty maintainer no longer applies, and others who are more
kitchen-sink-minded should take over.

The only drawback to adding toplevel libraries is coordinating changes
among the toplevel configury.
Tom Tromey - March 19, 2012, 5:23 p.m.
>>>>> "DJ" == DJ Delorie <dj@redhat.com> writes:

DJ> The only drawback to adding toplevel libraries is coordinating changes
DJ> among the toplevel configury.

And adding crud to Makefiles all over.

Pick a name for the new library and I will implement this.

Tom
Doug Evans - March 19, 2012, 10:48 p.m.
On Mon, Mar 19, 2012 at 9:09 AM, Doug Evans <dje@google.com> wrote:
> On Thu, Mar 15, 2012 at 12:02 PM, Tom Tromey <tromey@redhat.com> wrote:
>>>>>>> "DJ" == DJ Delorie <dj@redhat.com> writes:
>>
>> Tom> Finally, there is already stuff in libiberty not related to
>> Tom> portability.  E.g., hashtab or the demangler.
>>
>> DJ> Yeah, I know, hence my "Should I give up that premise?"
>>
>> Yeah.
>>
>> I am not sure there will ever be enough shared code to warrant a new
>> library, particularly because adding a new library is so expensive --
>> not just the configury stuff but also adding it to the link lines in the
>> Makefiles of all the tools that might need it.
>>
>> I suppose if I had my wish list implemented here, it would be to remove
>> the portability stuff from libiberty in favor of gnulib, and keep
>> libiberty as a higher-level library.
>
> That won't really fix libiberty being an ever growing kitchen sink.
>
> How hard would it really be to make it easier to add new libraries?
> It's not like we're expecting 100.
> But given the pushback for even one new library, I think we're
> unnecessarily slowing ourselves down.

btw,

While I like using gnulib more, do we know it will necessarily always
solve portability problems in a timely manner?  I wouldn't mind
keeping libiberty as a fallback.

Plus, some of the complexity of libiberty is supporting all of
$build,$host,$target in one build.
The utilities I think you're thinking of adding (or at least the
utilities I've come across as wanting to add to a more useful
location) are just for the tools (i.e. $host).  Putting them in
libiberty doesn't "feel right".
Nick Clifton - April 7, 2012, 1:58 p.m.
Hi Tom,

> Built and regtested on x86-64 Fedora 16.
>
> Ok?
>
> Tom
>
> 2012-03-15  Tom Tromey<tromey@redhat.com>
>
> 	* dwarf2out.c (dwarf_stack_op_name): Use get_DW_OP_name.
> 	(dwarf_tag_name): Use get_DW_TAG_name.
> 	(dwarf_attr_name): Use get_DW_AT_name.
> 	(dwarf_form_name): Use get_DW_FORM_name.
> 	* dwarf2cfi.c (dwarf_cfi_name): Use get_DW_CFA_name.
>
> 2012-03-15  Tom Tromey<tromey@redhat.com>
>
> 	* dwarf2.h (enum dwarf_tag, enum dwarf_form, enum dwarf_attribute)
> 	(enum dwarf_location_atom, enum dwarf_type, enum
> 	dwarf_call_frame_info): Remove.
> 	(DW_TAG, DW_TAG_DUP, DW_FORM, DW_AT, DW_AT_DUP, DW_OP)
> 	(DW_OP_DUP, DW_ATE, DW_ATE_DUP, DW_CFA): New macros.
> 	Include dwarf2.def.
> 	(get_DW_TAG_name, get_DW_AT_name, get_DW_FORM_name)
> 	(get_DW_OP_name, get_DW_ATE_name): Declare.
> 	* dwarf2.def: New file, from dwarf2.h.
>
> 2012-03-15  Tom Tromey<tromey@redhat.com>
>
> 	* dwarfnames.c: New file.
> 	* Makefile.in (CFILES): Add dwarfnames.
> 	(REQUIRED_OFILES): Add dwarfnames.
> 	(./dwarfnames.$(objext)): New target.

This is OK from a binutils point of view.

Cheers
   Nick

Patch

diff --git a/gcc/dwarf2cfi.c b/gcc/dwarf2cfi.c
index 2e74955..262dbfd 100644
--- a/gcc/dwarf2cfi.c
+++ b/gcc/dwarf2cfi.c
@@ -1,6 +1,6 @@ 
 /* Dwarf2 Call Frame Information helper routines.
    Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
-   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
    Free Software Foundation, Inc.
 
 This file is part of GCC.
@@ -2929,72 +2929,12 @@  execute_dwarf2_frame (void)
 static const char *
 dwarf_cfi_name (unsigned int cfi_opc)
 {
-  switch (cfi_opc)
-    {
-    case DW_CFA_advance_loc:
-      return "DW_CFA_advance_loc";
-    case DW_CFA_offset:
-      return "DW_CFA_offset";
-    case DW_CFA_restore:
-      return "DW_CFA_restore";
-    case DW_CFA_nop:
-      return "DW_CFA_nop";
-    case DW_CFA_set_loc:
-      return "DW_CFA_set_loc";
-    case DW_CFA_advance_loc1:
-      return "DW_CFA_advance_loc1";
-    case DW_CFA_advance_loc2:
-      return "DW_CFA_advance_loc2";
-    case DW_CFA_advance_loc4:
-      return "DW_CFA_advance_loc4";
-    case DW_CFA_offset_extended:
-      return "DW_CFA_offset_extended";
-    case DW_CFA_restore_extended:
-      return "DW_CFA_restore_extended";
-    case DW_CFA_undefined:
-      return "DW_CFA_undefined";
-    case DW_CFA_same_value:
-      return "DW_CFA_same_value";
-    case DW_CFA_register:
-      return "DW_CFA_register";
-    case DW_CFA_remember_state:
-      return "DW_CFA_remember_state";
-    case DW_CFA_restore_state:
-      return "DW_CFA_restore_state";
-    case DW_CFA_def_cfa:
-      return "DW_CFA_def_cfa";
-    case DW_CFA_def_cfa_register:
-      return "DW_CFA_def_cfa_register";
-    case DW_CFA_def_cfa_offset:
-      return "DW_CFA_def_cfa_offset";
+  const char *name = get_DW_CFA_name (cfi_opc);
 
-    /* DWARF 3 */
-    case DW_CFA_def_cfa_expression:
-      return "DW_CFA_def_cfa_expression";
-    case DW_CFA_expression:
-      return "DW_CFA_expression";
-    case DW_CFA_offset_extended_sf:
-      return "DW_CFA_offset_extended_sf";
-    case DW_CFA_def_cfa_sf:
-      return "DW_CFA_def_cfa_sf";
-    case DW_CFA_def_cfa_offset_sf:
-      return "DW_CFA_def_cfa_offset_sf";
+  if (name != NULL)
+    return name;
 
-    /* SGI/MIPS specific */
-    case DW_CFA_MIPS_advance_loc8:
-      return "DW_CFA_MIPS_advance_loc8";
-
-    /* GNU extensions */
-    case DW_CFA_GNU_window_save:
-      return "DW_CFA_GNU_window_save";
-    case DW_CFA_GNU_args_size:
-      return "DW_CFA_GNU_args_size";
-    case DW_CFA_GNU_negative_offset_extended:
-      return "DW_CFA_GNU_negative_offset_extended";
-
-    default:
-      return "DW_CFA_<unknown>";
-    }
+  return "DW_CFA_<unknown>";
 }
 
 /* This routine will generate the correct assembly data for a location
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index b5f921a..5163859 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -1234,344 +1234,12 @@  static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
 static const char *
 dwarf_stack_op_name (unsigned int op)
 {
-  switch (op)
-    {
-    case DW_OP_addr:
-      return "DW_OP_addr";
-    case DW_OP_deref:
-      return "DW_OP_deref";
-    case DW_OP_const1u:
-      return "DW_OP_const1u";
-    case DW_OP_const1s:
-      return "DW_OP_const1s";
-    case DW_OP_const2u:
-      return "DW_OP_const2u";
-    case DW_OP_const2s:
-      return "DW_OP_const2s";
-    case DW_OP_const4u:
-      return "DW_OP_const4u";
-    case DW_OP_const4s:
-      return "DW_OP_const4s";
-    case DW_OP_const8u:
-      return "DW_OP_const8u";
-    case DW_OP_const8s:
-      return "DW_OP_const8s";
-    case DW_OP_constu:
-      return "DW_OP_constu";
-    case DW_OP_consts:
-      return "DW_OP_consts";
-    case DW_OP_dup:
-      return "DW_OP_dup";
-    case DW_OP_drop:
-      return "DW_OP_drop";
-    case DW_OP_over:
-      return "DW_OP_over";
-    case DW_OP_pick:
-      return "DW_OP_pick";
-    case DW_OP_swap:
-      return "DW_OP_swap";
-    case DW_OP_rot:
-      return "DW_OP_rot";
-    case DW_OP_xderef:
-      return "DW_OP_xderef";
-    case DW_OP_abs:
-      return "DW_OP_abs";
-    case DW_OP_and:
-      return "DW_OP_and";
-    case DW_OP_div:
-      return "DW_OP_div";
-    case DW_OP_minus:
-      return "DW_OP_minus";
-    case DW_OP_mod:
-      return "DW_OP_mod";
-    case DW_OP_mul:
-      return "DW_OP_mul";
-    case DW_OP_neg:
-      return "DW_OP_neg";
-    case DW_OP_not:
-      return "DW_OP_not";
-    case DW_OP_or:
-      return "DW_OP_or";
-    case DW_OP_plus:
-      return "DW_OP_plus";
-    case DW_OP_plus_uconst:
-      return "DW_OP_plus_uconst";
-    case DW_OP_shl:
-      return "DW_OP_shl";
-    case DW_OP_shr:
-      return "DW_OP_shr";
-    case DW_OP_shra:
-      return "DW_OP_shra";
-    case DW_OP_xor:
-      return "DW_OP_xor";
-    case DW_OP_bra:
-      return "DW_OP_bra";
-    case DW_OP_eq:
-      return "DW_OP_eq";
-    case DW_OP_ge:
-      return "DW_OP_ge";
-    case DW_OP_gt:
-      return "DW_OP_gt";
-    case DW_OP_le:
-      return "DW_OP_le";
-    case DW_OP_lt:
-      return "DW_OP_lt";
-    case DW_OP_ne:
-      return "DW_OP_ne";
-    case DW_OP_skip:
-      return "DW_OP_skip";
-    case DW_OP_lit0:
-      return "DW_OP_lit0";
-    case DW_OP_lit1:
-      return "DW_OP_lit1";
-    case DW_OP_lit2:
-      return "DW_OP_lit2";
-    case DW_OP_lit3:
-      return "DW_OP_lit3";
-    case DW_OP_lit4:
-      return "DW_OP_lit4";
-    case DW_OP_lit5:
-      return "DW_OP_lit5";
-    case DW_OP_lit6:
-      return "DW_OP_lit6";
-    case DW_OP_lit7:
-      return "DW_OP_lit7";
-    case DW_OP_lit8:
-      return "DW_OP_lit8";
-    case DW_OP_lit9:
-      return "DW_OP_lit9";
-    case DW_OP_lit10:
-      return "DW_OP_lit10";
-    case DW_OP_lit11:
-      return "DW_OP_lit11";
-    case DW_OP_lit12:
-      return "DW_OP_lit12";
-    case DW_OP_lit13:
-      return "DW_OP_lit13";
-    case DW_OP_lit14:
-      return "DW_OP_lit14";
-    case DW_OP_lit15:
-      return "DW_OP_lit15";
-    case DW_OP_lit16:
-      return "DW_OP_lit16";
-    case DW_OP_lit17:
-      return "DW_OP_lit17";
-    case DW_OP_lit18:
-      return "DW_OP_lit18";
-    case DW_OP_lit19:
-      return "DW_OP_lit19";
-    case DW_OP_lit20:
-      return "DW_OP_lit20";
-    case DW_OP_lit21:
-      return "DW_OP_lit21";
-    case DW_OP_lit22:
-      return "DW_OP_lit22";
-    case DW_OP_lit23:
-      return "DW_OP_lit23";
-    case DW_OP_lit24:
-      return "DW_OP_lit24";
-    case DW_OP_lit25:
-      return "DW_OP_lit25";
-    case DW_OP_lit26:
-      return "DW_OP_lit26";
-    case DW_OP_lit27:
-      return "DW_OP_lit27";
-    case DW_OP_lit28:
-      return "DW_OP_lit28";
-    case DW_OP_lit29:
-      return "DW_OP_lit29";
-    case DW_OP_lit30:
-      return "DW_OP_lit30";
-    case DW_OP_lit31:
-      return "DW_OP_lit31";
-    case DW_OP_reg0:
-      return "DW_OP_reg0";
-    case DW_OP_reg1:
-      return "DW_OP_reg1";
-    case DW_OP_reg2:
-      return "DW_OP_reg2";
-    case DW_OP_reg3:
-      return "DW_OP_reg3";
-    case DW_OP_reg4:
-      return "DW_OP_reg4";
-    case DW_OP_reg5:
-      return "DW_OP_reg5";
-    case DW_OP_reg6:
-      return "DW_OP_reg6";
-    case DW_OP_reg7:
-      return "DW_OP_reg7";
-    case DW_OP_reg8:
-      return "DW_OP_reg8";
-    case DW_OP_reg9:
-      return "DW_OP_reg9";
-    case DW_OP_reg10:
-      return "DW_OP_reg10";
-    case DW_OP_reg11:
-      return "DW_OP_reg11";
-    case DW_OP_reg12:
-      return "DW_OP_reg12";
-    case DW_OP_reg13:
-      return "DW_OP_reg13";
-    case DW_OP_reg14:
-      return "DW_OP_reg14";
-    case DW_OP_reg15:
-      return "DW_OP_reg15";
-    case DW_OP_reg16:
-      return "DW_OP_reg16";
-    case DW_OP_reg17:
-      return "DW_OP_reg17";
-    case DW_OP_reg18:
-      return "DW_OP_reg18";
-    case DW_OP_reg19:
-      return "DW_OP_reg19";
-    case DW_OP_reg20:
-      return "DW_OP_reg20";
-    case DW_OP_reg21:
-      return "DW_OP_reg21";
-    case DW_OP_reg22:
-      return "DW_OP_reg22";
-    case DW_OP_reg23:
-      return "DW_OP_reg23";
-    case DW_OP_reg24:
-      return "DW_OP_reg24";
-    case DW_OP_reg25:
-      return "DW_OP_reg25";
-    case DW_OP_reg26:
-      return "DW_OP_reg26";
-    case DW_OP_reg27:
-      return "DW_OP_reg27";
-    case DW_OP_reg28:
-      return "DW_OP_reg28";
-    case DW_OP_reg29:
-      return "DW_OP_reg29";
-    case DW_OP_reg30:
-      return "DW_OP_reg30";
-    case DW_OP_reg31:
-      return "DW_OP_reg31";
-    case DW_OP_breg0:
-      return "DW_OP_breg0";
-    case DW_OP_breg1:
-      return "DW_OP_breg1";
-    case DW_OP_breg2:
-      return "DW_OP_breg2";
-    case DW_OP_breg3:
-      return "DW_OP_breg3";
-    case DW_OP_breg4:
-      return "DW_OP_breg4";
-    case DW_OP_breg5:
-      return "DW_OP_breg5";
-    case DW_OP_breg6:
-      return "DW_OP_breg6";
-    case DW_OP_breg7:
-      return "DW_OP_breg7";
-    case DW_OP_breg8:
-      return "DW_OP_breg8";
-    case DW_OP_breg9:
-      return "DW_OP_breg9";
-    case DW_OP_breg10:
-      return "DW_OP_breg10";
-    case DW_OP_breg11:
-      return "DW_OP_breg11";
-    case DW_OP_breg12:
-      return "DW_OP_breg12";
-    case DW_OP_breg13:
-      return "DW_OP_breg13";
-    case DW_OP_breg14:
-      return "DW_OP_breg14";
-    case DW_OP_breg15:
-      return "DW_OP_breg15";
-    case DW_OP_breg16:
-      return "DW_OP_breg16";
-    case DW_OP_breg17:
-      return "DW_OP_breg17";
-    case DW_OP_breg18:
-      return "DW_OP_breg18";
-    case DW_OP_breg19:
-      return "DW_OP_breg19";
-    case DW_OP_breg20:
-      return "DW_OP_breg20";
-    case DW_OP_breg21:
-      return "DW_OP_breg21";
-    case DW_OP_breg22:
-      return "DW_OP_breg22";
-    case DW_OP_breg23:
-      return "DW_OP_breg23";
-    case DW_OP_breg24:
-      return "DW_OP_breg24";
-    case DW_OP_breg25:
-      return "DW_OP_breg25";
-    case DW_OP_breg26:
-      return "DW_OP_breg26";
-    case DW_OP_breg27:
-      return "DW_OP_breg27";
-    case DW_OP_breg28:
-      return "DW_OP_breg28";
-    case DW_OP_breg29:
-      return "DW_OP_breg29";
-    case DW_OP_breg30:
-      return "DW_OP_breg30";
-    case DW_OP_breg31:
-      return "DW_OP_breg31";
-    case DW_OP_regx:
-      return "DW_OP_regx";
-    case DW_OP_fbreg:
-      return "DW_OP_fbreg";
-    case DW_OP_bregx:
-      return "DW_OP_bregx";
-    case DW_OP_piece:
-      return "DW_OP_piece";
-    case DW_OP_deref_size:
-      return "DW_OP_deref_size";
-    case DW_OP_xderef_size:
-      return "DW_OP_xderef_size";
-    case DW_OP_nop:
-      return "DW_OP_nop";
+  const char *name = get_DW_OP_name (op);
 
-    case DW_OP_push_object_address:
-      return "DW_OP_push_object_address";
-    case DW_OP_call2:
-      return "DW_OP_call2";
-    case DW_OP_call4:
-      return "DW_OP_call4";
-    case DW_OP_call_ref:
-      return "DW_OP_call_ref";
-    case DW_OP_implicit_value:
-      return "DW_OP_implicit_value";
-    case DW_OP_stack_value:
-      return "DW_OP_stack_value";
-    case DW_OP_form_tls_address:
-      return "DW_OP_form_tls_address";
-    case DW_OP_call_frame_cfa:
-      return "DW_OP_call_frame_cfa";
-    case DW_OP_bit_piece:
-      return "DW_OP_bit_piece";
-
-    case DW_OP_GNU_push_tls_address:
-      return "DW_OP_GNU_push_tls_address";
-    case DW_OP_GNU_uninit:
-      return "DW_OP_GNU_uninit";
-    case DW_OP_GNU_encoded_addr:
-      return "DW_OP_GNU_encoded_addr";
-    case DW_OP_GNU_implicit_pointer:
-      return "DW_OP_GNU_implicit_pointer";
-    case DW_OP_GNU_entry_value:
-      return "DW_OP_GNU_entry_value";
-    case DW_OP_GNU_const_type:
-      return "DW_OP_GNU_const_type";
-    case DW_OP_GNU_regval_type:
-      return "DW_OP_GNU_regval_type";
-    case DW_OP_GNU_deref_type:
-      return "DW_OP_GNU_deref_type";
-    case DW_OP_GNU_convert:
-      return "DW_OP_GNU_convert";
-    case DW_OP_GNU_reinterpret:
-      return "DW_OP_GNU_reinterpret";
-    case DW_OP_GNU_parameter_ref:
-      return "DW_OP_GNU_parameter_ref";
+  if (name != NULL)
+    return name;
 
-    default:
-      return "OP_<unknown>";
-    }
+  return "OP_<unknown>";
 }
 
 /* Return a pointer to a newly allocated location description.  Location
@@ -3700,155 +3368,12 @@  get_ref_die_offset (dw_die_ref ref)
 static const char *
 dwarf_tag_name (unsigned int tag)
 {
-  switch (tag)
-    {
-    case DW_TAG_padding:
-      return "DW_TAG_padding";
-    case DW_TAG_array_type:
-      return "DW_TAG_array_type";
-    case DW_TAG_class_type:
-      return "DW_TAG_class_type";
-    case DW_TAG_entry_point:
-      return "DW_TAG_entry_point";
-    case DW_TAG_enumeration_type:
-      return "DW_TAG_enumeration_type";
-    case DW_TAG_formal_parameter:
-      return "DW_TAG_formal_parameter";
-    case DW_TAG_imported_declaration:
-      return "DW_TAG_imported_declaration";
-    case DW_TAG_label:
-      return "DW_TAG_label";
-    case DW_TAG_lexical_block:
-      return "DW_TAG_lexical_block";
-    case DW_TAG_member:
-      return "DW_TAG_member";
-    case DW_TAG_pointer_type:
-      return "DW_TAG_pointer_type";
-    case DW_TAG_reference_type:
-      return "DW_TAG_reference_type";
-    case DW_TAG_compile_unit:
-      return "DW_TAG_compile_unit";
-    case DW_TAG_string_type:
-      return "DW_TAG_string_type";
-    case DW_TAG_structure_type:
-      return "DW_TAG_structure_type";
-    case DW_TAG_subroutine_type:
-      return "DW_TAG_subroutine_type";
-    case DW_TAG_typedef:
-      return "DW_TAG_typedef";
-    case DW_TAG_union_type:
-      return "DW_TAG_union_type";
-    case DW_TAG_unspecified_parameters:
-      return "DW_TAG_unspecified_parameters";
-    case DW_TAG_variant:
-      return "DW_TAG_variant";
-    case DW_TAG_common_block:
-      return "DW_TAG_common_block";
-    case DW_TAG_common_inclusion:
-      return "DW_TAG_common_inclusion";
-    case DW_TAG_inheritance:
-      return "DW_TAG_inheritance";
-    case DW_TAG_inlined_subroutine:
-      return "DW_TAG_inlined_subroutine";
-    case DW_TAG_module:
-      return "DW_TAG_module";
-    case DW_TAG_ptr_to_member_type:
-      return "DW_TAG_ptr_to_member_type";
-    case DW_TAG_set_type:
-      return "DW_TAG_set_type";
-    case DW_TAG_subrange_type:
-      return "DW_TAG_subrange_type";
-    case DW_TAG_with_stmt:
-      return "DW_TAG_with_stmt";
-    case DW_TAG_access_declaration:
-      return "DW_TAG_access_declaration";
-    case DW_TAG_base_type:
-      return "DW_TAG_base_type";
-    case DW_TAG_catch_block:
-      return "DW_TAG_catch_block";
-    case DW_TAG_const_type:
-      return "DW_TAG_const_type";
-    case DW_TAG_constant:
-      return "DW_TAG_constant";
-    case DW_TAG_enumerator:
-      return "DW_TAG_enumerator";
-    case DW_TAG_file_type:
-      return "DW_TAG_file_type";
-    case DW_TAG_friend:
-      return "DW_TAG_friend";
-    case DW_TAG_namelist:
-      return "DW_TAG_namelist";
-    case DW_TAG_namelist_item:
-      return "DW_TAG_namelist_item";
-    case DW_TAG_packed_type:
-      return "DW_TAG_packed_type";
-    case DW_TAG_subprogram:
-      return "DW_TAG_subprogram";
-    case DW_TAG_template_type_param:
-      return "DW_TAG_template_type_param";
-    case DW_TAG_template_value_param:
-      return "DW_TAG_template_value_param";
-    case DW_TAG_thrown_type:
-      return "DW_TAG_thrown_type";
-    case DW_TAG_try_block:
-      return "DW_TAG_try_block";
-    case DW_TAG_variant_part:
-      return "DW_TAG_variant_part";
-    case DW_TAG_variable:
-      return "DW_TAG_variable";
-    case DW_TAG_volatile_type:
-      return "DW_TAG_volatile_type";
-    case DW_TAG_dwarf_procedure:
-      return "DW_TAG_dwarf_procedure";
-    case DW_TAG_restrict_type:
-      return "DW_TAG_restrict_type";
-    case DW_TAG_interface_type:
-      return "DW_TAG_interface_type";
-    case DW_TAG_namespace:
-      return "DW_TAG_namespace";
-    case DW_TAG_imported_module:
-      return "DW_TAG_imported_module";
-    case DW_TAG_unspecified_type:
-      return "DW_TAG_unspecified_type";
-    case DW_TAG_partial_unit:
-      return "DW_TAG_partial_unit";
-    case DW_TAG_imported_unit:
-      return "DW_TAG_imported_unit";
-    case DW_TAG_condition:
-      return "DW_TAG_condition";
-    case DW_TAG_shared_type:
-      return "DW_TAG_shared_type";
-    case DW_TAG_type_unit:
-      return "DW_TAG_type_unit";
-    case DW_TAG_rvalue_reference_type:
-      return "DW_TAG_rvalue_reference_type";
-    case DW_TAG_template_alias:
-      return "DW_TAG_template_alias";
-    case DW_TAG_GNU_template_parameter_pack:
-      return "DW_TAG_GNU_template_parameter_pack";
-    case DW_TAG_GNU_formal_parameter_pack:
-      return "DW_TAG_GNU_formal_parameter_pack";
-    case DW_TAG_MIPS_loop:
-      return "DW_TAG_MIPS_loop";
-    case DW_TAG_format_label:
-      return "DW_TAG_format_label";
-    case DW_TAG_function_template:
-      return "DW_TAG_function_template";
-    case DW_TAG_class_template:
-      return "DW_TAG_class_template";
-    case DW_TAG_GNU_BINCL:
-      return "DW_TAG_GNU_BINCL";
-    case DW_TAG_GNU_EINCL:
-      return "DW_TAG_GNU_EINCL";
-    case DW_TAG_GNU_template_template_param:
-      return "DW_TAG_GNU_template_template_param";
-    case DW_TAG_GNU_call_site:
-      return "DW_TAG_GNU_call_site";
-    case DW_TAG_GNU_call_site_parameter:
-      return "DW_TAG_GNU_call_site_parameter";
-    default:
-      return "DW_TAG_<unknown>";
-    }
+  const char *name = get_DW_TAG_name (tag);
+
+  if (name != NULL)
+    return name;
+
+  return "DW_TAG_<unknown>";
 }
 
 /* Convert a DWARF attribute code into its string name.  */
@@ -3856,183 +3381,10 @@  dwarf_tag_name (unsigned int tag)
 static const char *
 dwarf_attr_name (unsigned int attr)
 {
+  const char *name;
+
   switch (attr)
     {
-    case DW_AT_sibling:
-      return "DW_AT_sibling";
-    case DW_AT_location:
-      return "DW_AT_location";
-    case DW_AT_name:
-      return "DW_AT_name";
-    case DW_AT_ordering:
-      return "DW_AT_ordering";
-    case DW_AT_subscr_data:
-      return "DW_AT_subscr_data";
-    case DW_AT_byte_size:
-      return "DW_AT_byte_size";
-    case DW_AT_bit_offset:
-      return "DW_AT_bit_offset";
-    case DW_AT_bit_size:
-      return "DW_AT_bit_size";
-    case DW_AT_element_list:
-      return "DW_AT_element_list";
-    case DW_AT_stmt_list:
-      return "DW_AT_stmt_list";
-    case DW_AT_low_pc:
-      return "DW_AT_low_pc";
-    case DW_AT_high_pc:
-      return "DW_AT_high_pc";
-    case DW_AT_language:
-      return "DW_AT_language";
-    case DW_AT_member:
-      return "DW_AT_member";
-    case DW_AT_discr:
-      return "DW_AT_discr";
-    case DW_AT_discr_value:
-      return "DW_AT_discr_value";
-    case DW_AT_visibility:
-      return "DW_AT_visibility";
-    case DW_AT_import:
-      return "DW_AT_import";
-    case DW_AT_string_length:
-      return "DW_AT_string_length";
-    case DW_AT_common_reference:
-      return "DW_AT_common_reference";
-    case DW_AT_comp_dir:
-      return "DW_AT_comp_dir";
-    case DW_AT_const_value:
-      return "DW_AT_const_value";
-    case DW_AT_containing_type:
-      return "DW_AT_containing_type";
-    case DW_AT_default_value:
-      return "DW_AT_default_value";
-    case DW_AT_inline:
-      return "DW_AT_inline";
-    case DW_AT_is_optional:
-      return "DW_AT_is_optional";
-    case DW_AT_lower_bound:
-      return "DW_AT_lower_bound";
-    case DW_AT_producer:
-      return "DW_AT_producer";
-    case DW_AT_prototyped:
-      return "DW_AT_prototyped";
-    case DW_AT_return_addr:
-      return "DW_AT_return_addr";
-    case DW_AT_start_scope:
-      return "DW_AT_start_scope";
-    case DW_AT_bit_stride:
-      return "DW_AT_bit_stride";
-    case DW_AT_upper_bound:
-      return "DW_AT_upper_bound";
-    case DW_AT_abstract_origin:
-      return "DW_AT_abstract_origin";
-    case DW_AT_accessibility:
-      return "DW_AT_accessibility";
-    case DW_AT_address_class:
-      return "DW_AT_address_class";
-    case DW_AT_artificial:
-      return "DW_AT_artificial";
-    case DW_AT_base_types:
-      return "DW_AT_base_types";
-    case DW_AT_calling_convention:
-      return "DW_AT_calling_convention";
-    case DW_AT_count:
-      return "DW_AT_count";
-    case DW_AT_data_member_location:
-      return "DW_AT_data_member_location";
-    case DW_AT_decl_column:
-      return "DW_AT_decl_column";
-    case DW_AT_decl_file:
-      return "DW_AT_decl_file";
-    case DW_AT_decl_line:
-      return "DW_AT_decl_line";
-    case DW_AT_declaration:
-      return "DW_AT_declaration";
-    case DW_AT_discr_list:
-      return "DW_AT_discr_list";
-    case DW_AT_encoding:
-      return "DW_AT_encoding";
-    case DW_AT_external:
-      return "DW_AT_external";
-    case DW_AT_explicit:
-      return "DW_AT_explicit";
-    case DW_AT_frame_base:
-      return "DW_AT_frame_base";
-    case DW_AT_friend:
-      return "DW_AT_friend";
-    case DW_AT_identifier_case:
-      return "DW_AT_identifier_case";
-    case DW_AT_macro_info:
-      return "DW_AT_macro_info";
-    case DW_AT_namelist_items:
-      return "DW_AT_namelist_items";
-    case DW_AT_priority:
-      return "DW_AT_priority";
-    case DW_AT_segment:
-      return "DW_AT_segment";
-    case DW_AT_specification:
-      return "DW_AT_specification";
-    case DW_AT_static_link:
-      return "DW_AT_static_link";
-    case DW_AT_type:
-      return "DW_AT_type";
-    case DW_AT_use_location:
-      return "DW_AT_use_location";
-    case DW_AT_variable_parameter:
-      return "DW_AT_variable_parameter";
-    case DW_AT_virtuality:
-      return "DW_AT_virtuality";
-    case DW_AT_vtable_elem_location:
-      return "DW_AT_vtable_elem_location";
-
-    case DW_AT_allocated:
-      return "DW_AT_allocated";
-    case DW_AT_associated:
-      return "DW_AT_associated";
-    case DW_AT_data_location:
-      return "DW_AT_data_location";
-    case DW_AT_byte_stride:
-      return "DW_AT_byte_stride";
-    case DW_AT_entry_pc:
-      return "DW_AT_entry_pc";
-    case DW_AT_use_UTF8:
-      return "DW_AT_use_UTF8";
-    case DW_AT_extension:
-      return "DW_AT_extension";
-    case DW_AT_ranges:
-      return "DW_AT_ranges";
-    case DW_AT_trampoline:
-      return "DW_AT_trampoline";
-    case DW_AT_call_column:
-      return "DW_AT_call_column";
-    case DW_AT_call_file:
-      return "DW_AT_call_file";
-    case DW_AT_call_line:
-      return "DW_AT_call_line";
-    case DW_AT_object_pointer:
-      return "DW_AT_object_pointer";
-
-    case DW_AT_signature:
-      return "DW_AT_signature";
-    case DW_AT_main_subprogram:
-      return "DW_AT_main_subprogram";
-    case DW_AT_data_bit_offset:
-      return "DW_AT_data_bit_offset";
-    case DW_AT_const_expr:
-      return "DW_AT_const_expr";
-    case DW_AT_enum_class:
-      return "DW_AT_enum_class";
-    case DW_AT_linkage_name:
-      return "DW_AT_linkage_name";
-
-    case DW_AT_MIPS_fde:
-      return "DW_AT_MIPS_fde";
-    case DW_AT_MIPS_loop_begin:
-      return "DW_AT_MIPS_loop_begin";
-    case DW_AT_MIPS_tail_loop_begin:
-      return "DW_AT_MIPS_tail_loop_begin";
-    case DW_AT_MIPS_epilog_begin:
-      return "DW_AT_MIPS_epilog_begin";
 #if VMS_DEBUGGING_INFO
     case DW_AT_HP_prologue:
       return "DW_AT_HP_prologue";
@@ -4040,10 +3392,7 @@  dwarf_attr_name (unsigned int attr)
     case DW_AT_MIPS_loop_unroll_factor:
       return "DW_AT_MIPS_loop_unroll_factor";
 #endif
-    case DW_AT_MIPS_software_pipeline_depth:
-      return "DW_AT_MIPS_software_pipeline_depth";
-    case DW_AT_MIPS_linkage_name:
-      return "DW_AT_MIPS_linkage_name";
+
 #if VMS_DEBUGGING_INFO
     case DW_AT_HP_epilogue:
       return "DW_AT_HP_epilogue";
@@ -4051,74 +3400,14 @@  dwarf_attr_name (unsigned int attr)
     case DW_AT_MIPS_stride:
       return "DW_AT_MIPS_stride";
 #endif
-    case DW_AT_MIPS_abstract_name:
-      return "DW_AT_MIPS_abstract_name";
-    case DW_AT_MIPS_clone_origin:
-      return "DW_AT_MIPS_clone_origin";
-    case DW_AT_MIPS_has_inlines:
-      return "DW_AT_MIPS_has_inlines";
-
-    case DW_AT_sf_names:
-      return "DW_AT_sf_names";
-    case DW_AT_src_info:
-      return "DW_AT_src_info";
-    case DW_AT_mac_info:
-      return "DW_AT_mac_info";
-    case DW_AT_src_coords:
-      return "DW_AT_src_coords";
-    case DW_AT_body_begin:
-      return "DW_AT_body_begin";
-    case DW_AT_body_end:
-      return "DW_AT_body_end";
-
-    case DW_AT_GNU_vector:
-      return "DW_AT_GNU_vector";
-    case DW_AT_GNU_guarded_by:
-      return "DW_AT_GNU_guarded_by";
-    case DW_AT_GNU_pt_guarded_by:
-      return "DW_AT_GNU_pt_guarded_by";
-    case DW_AT_GNU_guarded:
-      return "DW_AT_GNU_guarded";
-    case DW_AT_GNU_pt_guarded:
-      return "DW_AT_GNU_pt_guarded";
-    case DW_AT_GNU_locks_excluded:
-      return "DW_AT_GNU_locks_excluded";
-    case DW_AT_GNU_exclusive_locks_required:
-      return "DW_AT_GNU_exclusive_locks_required";
-    case DW_AT_GNU_shared_locks_required:
-      return "DW_AT_GNU_shared_locks_required";
-    case DW_AT_GNU_odr_signature:
-      return "DW_AT_GNU_odr_signature";
-    case DW_AT_GNU_template_name:
-      return "DW_AT_GNU_template_name";
-    case DW_AT_GNU_call_site_value:
-      return "DW_AT_GNU_call_site_value";
-    case DW_AT_GNU_call_site_data_value:
-      return "DW_AT_GNU_call_site_data_value";
-    case DW_AT_GNU_call_site_target:
-      return "DW_AT_GNU_call_site_target";
-    case DW_AT_GNU_call_site_target_clobbered:
-      return "DW_AT_GNU_call_site_target_clobbered";
-    case DW_AT_GNU_tail_call:
-      return "DW_AT_GNU_tail_call";
-    case DW_AT_GNU_all_tail_call_sites:
-      return "DW_AT_GNU_all_tail_call_sites";
-    case DW_AT_GNU_all_call_sites:
-      return "DW_AT_GNU_all_call_sites";
-    case DW_AT_GNU_all_source_call_sites:
-      return "DW_AT_GNU_all_source_call_sites";
-    case DW_AT_GNU_macros:
-      return "DW_AT_GNU_macros";
-
-    case DW_AT_GNAT_descriptive_type:
-      return "DW_AT_GNAT_descriptive_type";
-
-    case DW_AT_VMS_rtnbeg_pd_address:
-      return "DW_AT_VMS_rtnbeg_pd_address";
-
-    default:
-      return "DW_AT_<unknown>";
     }
+
+  name = get_DW_AT_name (attr);
+
+  if (name != NULL)
+    return name;
+
+  return "DW_AT_<unknown>";
 }
 
 /* Convert a DWARF value form code into its string name.  */
@@ -4126,61 +3415,12 @@  dwarf_attr_name (unsigned int attr)
 static const char *
 dwarf_form_name (unsigned int form)
 {
-  switch (form)
-    {
-    case DW_FORM_addr:
-      return "DW_FORM_addr";
-    case DW_FORM_block2:
-      return "DW_FORM_block2";
-    case DW_FORM_block4:
-      return "DW_FORM_block4";
-    case DW_FORM_data2:
-      return "DW_FORM_data2";
-    case DW_FORM_data4:
-      return "DW_FORM_data4";
-    case DW_FORM_data8:
-      return "DW_FORM_data8";
-    case DW_FORM_string:
-      return "DW_FORM_string";
-    case DW_FORM_block:
-      return "DW_FORM_block";
-    case DW_FORM_block1:
-      return "DW_FORM_block1";
-    case DW_FORM_data1:
-      return "DW_FORM_data1";
-    case DW_FORM_flag:
-      return "DW_FORM_flag";
-    case DW_FORM_sdata:
-      return "DW_FORM_sdata";
-    case DW_FORM_strp:
-      return "DW_FORM_strp";
-    case DW_FORM_udata:
-      return "DW_FORM_udata";
-    case DW_FORM_ref_addr:
-      return "DW_FORM_ref_addr";
-    case DW_FORM_ref1:
-      return "DW_FORM_ref1";
-    case DW_FORM_ref2:
-      return "DW_FORM_ref2";
-    case DW_FORM_ref4:
-      return "DW_FORM_ref4";
-    case DW_FORM_ref8:
-      return "DW_FORM_ref8";
-    case DW_FORM_ref_udata:
-      return "DW_FORM_ref_udata";
-    case DW_FORM_indirect:
-      return "DW_FORM_indirect";
-    case DW_FORM_sec_offset:
-      return "DW_FORM_sec_offset";
-    case DW_FORM_exprloc:
-      return "DW_FORM_exprloc";
-    case DW_FORM_flag_present:
-      return "DW_FORM_flag_present";
-    case DW_FORM_ref_sig8:
-      return "DW_FORM_ref_sig8";
-    default:
-      return "DW_FORM_<unknown>";
-    }
+  const char *name = get_DW_FORM_name (form);
+
+  if (name != NULL)
+    return name;
+
+  return "DW_FORM_<unknown>";
 }
 
 /* Determine the "ultimate origin" of a decl.  The decl may be an inlined
diff --git a/include/dwarf2.def b/include/dwarf2.def
new file mode 100644
index 0000000..cfa3f7b
--- /dev/null
+++ b/include/dwarf2.def
@@ -0,0 +1,679 @@ 
+/* -*- c -*-
+   Declarations and definitions of codes relating to the DWARF2 and
+   DWARF3 symbolic debugging information formats.
+   Copyright (C) 1992, 1993, 1995, 1996, 1997, 1999, 2000, 2001, 2002,
+   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
+   Free Software Foundation, Inc.
+
+   Written by Gary Funck (gary@intrepid.com) The Ada Joint Program
+   Office (AJPO), Florida State University and Silicon Graphics Inc.
+   provided support for this effort -- June 21, 1995.
+
+   Derived from the DWARF 1 implementation written by Ron Guilmette
+   (rfg@netcom.com), November 1990.
+
+   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 3, 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.
+
+   Under Section 7 of GPL version 3, you are granted additional
+   permissions described in the GCC Runtime Library Exception, version
+   3.1, as published by the Free Software Foundation.
+
+   You should have received a copy of the GNU General Public License and
+   a copy of the GCC Runtime Library Exception along with this program;
+   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+   <http://www.gnu.org/licenses/>.  */
+
+/* This file is derived from the DWARF specification (a public document)
+   Revision 2.0.0 (July 27, 1993) developed by the UNIX International
+   Programming Languages Special Interest Group (UI/PLSIG) and distributed
+   by UNIX International.  Copies of this specification are available from
+   UNIX International, 20 Waterview Boulevard, Parsippany, NJ, 07054.
+
+   This file also now contains definitions from the DWARF 3 specification
+   published Dec 20, 2005, available from: http://dwarf.freestandards.org.
+
+   This file also now contains definitions from the DWARF 4
+   specification, available from: http://dwarfstd.org/ */
+
+/* This file declares various DWARF-related constants using a set of
+   macros which can be redefined by the including file.
+   
+   The macros are in sections.  Each section corresponds to a single
+   set of DWARF constants and has a corresponding key.  The key is
+   used in all the macro names.
+   
+   The sections are TAG (for DW_TAG_ constants), FORM (DW_FORM_), AT
+   (DW_AT_), OP (DW_OP_), ATE (DW_ATE_), and CFA (DW_CFA_).
+   
+   Using TAG as an example, the following macros may be used for each
+   key:
+   
+   DW_FIRST_TAG(name, value) - Introduce the first DW_TAG constant.
+   
+   DW_TAG(name, value) - Define a subsequent constant.
+   
+   DW_TAG_DUP(name, value) - Define a subsequent constant whose value
+   is a duplicate of some other constant.  Not all keys use the _DUP
+   macro form.  If more than one name shares a value, then the base
+   (DW_TAG) form will be the preferred name and DW_TAG_DUP will hold
+   any alternate names.
+   
+   DW_END_TAG - Invoked at the end of the DW_TAG constants.  */
+
+DW_FIRST_TAG (_padding, 0x00)
+DW_TAG (_array_type, 0x01)
+DW_TAG (_class_type, 0x02)
+DW_TAG (_entry_point, 0x03)
+DW_TAG (_enumeration_type, 0x04)
+DW_TAG (_formal_parameter, 0x05)
+DW_TAG (_imported_declaration, 0x08)
+DW_TAG (_label, 0x0a)
+DW_TAG (_lexical_block, 0x0b)
+DW_TAG (_member, 0x0d)
+DW_TAG (_pointer_type, 0x0f)
+DW_TAG (_reference_type, 0x10)
+DW_TAG (_compile_unit, 0x11)
+DW_TAG (_string_type, 0x12)
+DW_TAG (_structure_type, 0x13)
+DW_TAG (_subroutine_type, 0x15)
+DW_TAG (_typedef, 0x16)
+DW_TAG (_union_type, 0x17)
+DW_TAG (_unspecified_parameters, 0x18)
+DW_TAG (_variant, 0x19)
+DW_TAG (_common_block, 0x1a)
+DW_TAG (_common_inclusion, 0x1b)
+DW_TAG (_inheritance, 0x1c)
+DW_TAG (_inlined_subroutine, 0x1d)
+DW_TAG (_module, 0x1e)
+DW_TAG (_ptr_to_member_type, 0x1f)
+DW_TAG (_set_type, 0x20)
+DW_TAG (_subrange_type, 0x21)
+DW_TAG (_with_stmt, 0x22)
+DW_TAG (_access_declaration, 0x23)
+DW_TAG (_base_type, 0x24)
+DW_TAG (_catch_block, 0x25)
+DW_TAG (_const_type, 0x26)
+DW_TAG (_constant, 0x27)
+DW_TAG (_enumerator, 0x28)
+DW_TAG (_file_type, 0x29)
+DW_TAG (_friend, 0x2a)
+DW_TAG (_namelist, 0x2b)
+DW_TAG (_namelist_item, 0x2c)
+DW_TAG (_packed_type, 0x2d)
+DW_TAG (_subprogram, 0x2e)
+DW_TAG (_template_type_param, 0x2f)
+DW_TAG (_template_value_param, 0x30)
+DW_TAG (_thrown_type, 0x31)
+DW_TAG (_try_block, 0x32)
+DW_TAG (_variant_part, 0x33)
+DW_TAG (_variable, 0x34)
+DW_TAG (_volatile_type, 0x35)
+/* DWARF 3.  */
+DW_TAG (_dwarf_procedure, 0x36)
+DW_TAG (_restrict_type, 0x37)
+DW_TAG (_interface_type, 0x38)
+DW_TAG (_namespace, 0x39)
+DW_TAG (_imported_module, 0x3a)
+DW_TAG (_unspecified_type, 0x3b)
+DW_TAG (_partial_unit, 0x3c)
+DW_TAG (_imported_unit, 0x3d)
+DW_TAG (_condition, 0x3f)
+DW_TAG (_shared_type, 0x40)
+/* DWARF 4.  */
+DW_TAG (_type_unit, 0x41)
+DW_TAG (_rvalue_reference_type, 0x42)
+DW_TAG (_template_alias, 0x43)
+
+DW_TAG_DUP (_lo_user, 0x4080)
+DW_TAG_DUP (_hi_user, 0xffff)
+
+/* SGI/MIPS Extensions.  */
+DW_TAG (_MIPS_loop, 0x4081)
+
+/* HP extensions.  See: ftp://ftp.hp.com/pub/lang/tools/WDB/wdb-4.0.tar.gz .  */
+DW_TAG (_HP_array_descriptor, 0x4090)
+DW_TAG (_HP_Bliss_field, 0x4091)
+DW_TAG (_HP_Bliss_field_set, 0x4092)
+
+/* GNU extensions.  */
+DW_TAG (_format_label, 0x4101)	/* For FORTRAN 77 and Fortran 90.  */
+DW_TAG (_function_template, 0x4102)	/* For C++.  */
+DW_TAG (_class_template, 0x4103)	/* For C++.  */
+DW_TAG (_GNU_BINCL, 0x4104)
+DW_TAG (_GNU_EINCL, 0x4105)
+/* Template template parameter.
+   See http://gcc.gnu.org/wiki/TemplateParmsDwarf .  */
+DW_TAG (_GNU_template_template_param, 0x4106)
+
+/* Template parameter pack extension, specified at
+   http://wiki.dwarfstd.org/index.php?title=C%2B%2B0x:_Variadic_templates
+   The values of these two TAGS are in the DW_TAG_GNU_* space until the tags
+   are properly part of DWARF 5.  */
+DW_TAG (_GNU_template_parameter_pack, 0x4107)
+DW_TAG (_GNU_formal_parameter_pack, 0x4108)
+/* The GNU call site extension, specified at
+   http://www.dwarfstd.org/ShowIssue.php?issue=100909.2&type=open .
+   The values of these two TAGS are in the DW_TAG_GNU_* space until the tags
+   are properly part of DWARF 5.  */
+DW_TAG (_GNU_call_site, 0x4109)
+DW_TAG (_GNU_call_site_parameter, 0x410a)
+/* Extensions for UPC.  See: http://upc.gwu.edu/~upc.  */
+DW_TAG (_upc_shared_type, 0x8765)
+DW_TAG (_upc_strict_type, 0x8766)
+DW_TAG (_upc_relaxed_type, 0x8767)
+/* PGI (STMicroelectronics) extensions.  No documentation available.  */
+DW_TAG (_PGI_kanji_type, 0xA000)
+DW_TAG (_PGI_interface_block, 0xA020)
+DW_END_TAG
+
+DW_FIRST_FORM (_addr, 0x01)
+DW_FORM (_block2, 0x03)
+DW_FORM (_block4, 0x04)
+DW_FORM (_data2, 0x05)
+DW_FORM (_data4, 0x06)
+DW_FORM (_data8, 0x07)
+DW_FORM (_string, 0x08)
+DW_FORM (_block, 0x09)
+DW_FORM (_block1, 0x0a)
+DW_FORM (_data1, 0x0b)
+DW_FORM (_flag, 0x0c)
+DW_FORM (_sdata, 0x0d)
+DW_FORM (_strp, 0x0e)
+DW_FORM (_udata, 0x0f)
+DW_FORM (_ref_addr, 0x10)
+DW_FORM (_ref1, 0x11)
+DW_FORM (_ref2, 0x12)
+DW_FORM (_ref4, 0x13)
+DW_FORM (_ref8, 0x14)
+DW_FORM (_ref_udata, 0x15)
+DW_FORM (_indirect, 0x16)
+/* DWARF 4.  */
+DW_FORM (_sec_offset, 0x17)
+DW_FORM (_exprloc, 0x18)
+DW_FORM (_flag_present, 0x19)
+DW_FORM (_ref_sig8, 0x20)
+/* Extensions for Fission.  See http://gcc.gnu.org/wiki/DebugFission.  */
+DW_FORM (_GNU_ref_index, 0x1f00)
+DW_FORM (_GNU_addr_index, 0x1f01)
+DW_FORM (_GNU_str_index, 0x1f02)
+DW_END_FORM
+
+DW_FIRST_AT (_sibling, 0x01)
+DW_AT (_location, 0x02)
+DW_AT (_name, 0x03)
+DW_AT (_ordering, 0x09)
+DW_AT (_subscr_data, 0x0a)
+DW_AT (_byte_size, 0x0b)
+DW_AT (_bit_offset, 0x0c)
+DW_AT (_bit_size, 0x0d)
+DW_AT (_element_list, 0x0f)
+DW_AT (_stmt_list, 0x10)
+DW_AT (_low_pc, 0x11)
+DW_AT (_high_pc, 0x12)
+DW_AT (_language, 0x13)
+DW_AT (_member, 0x14)
+DW_AT (_discr, 0x15)
+DW_AT (_discr_value, 0x16)
+DW_AT (_visibility, 0x17)
+DW_AT (_import, 0x18)
+DW_AT (_string_length, 0x19)
+DW_AT (_common_reference, 0x1a)
+DW_AT (_comp_dir, 0x1b)
+DW_AT (_const_value, 0x1c)
+DW_AT (_containing_type, 0x1d)
+DW_AT (_default_value, 0x1e)
+DW_AT (_inline, 0x20)
+DW_AT (_is_optional, 0x21)
+DW_AT (_lower_bound, 0x22)
+DW_AT (_producer, 0x25)
+DW_AT (_prototyped, 0x27)
+DW_AT (_return_addr, 0x2a)
+DW_AT (_start_scope, 0x2c)
+DW_AT (_bit_stride, 0x2e)
+DW_AT (_upper_bound, 0x2f)
+DW_AT (_abstract_origin, 0x31)
+DW_AT (_accessibility, 0x32)
+DW_AT (_address_class, 0x33)
+DW_AT (_artificial, 0x34)
+DW_AT (_base_types, 0x35)
+DW_AT (_calling_convention, 0x36)
+DW_AT (_count, 0x37)
+DW_AT (_data_member_location, 0x38)
+DW_AT (_decl_column, 0x39)
+DW_AT (_decl_file, 0x3a)
+DW_AT (_decl_line, 0x3b)
+DW_AT (_declaration, 0x3c)
+DW_AT (_discr_list, 0x3d)
+DW_AT (_encoding, 0x3e)
+DW_AT (_external, 0x3f)
+DW_AT (_frame_base, 0x40)
+DW_AT (_friend, 0x41)
+DW_AT (_identifier_case, 0x42)
+DW_AT (_macro_info, 0x43)
+DW_AT (_namelist_items, 0x44)
+DW_AT (_priority, 0x45)
+DW_AT (_segment, 0x46)
+DW_AT (_specification, 0x47)
+DW_AT (_static_link, 0x48)
+DW_AT (_type, 0x49)
+DW_AT (_use_location, 0x4a)
+DW_AT (_variable_parameter, 0x4b)
+DW_AT (_virtuality, 0x4c)
+DW_AT (_vtable_elem_location, 0x4d)
+/* DWARF 3 values.  */
+DW_AT (_allocated, 0x4e)
+DW_AT (_associated, 0x4f)
+DW_AT (_data_location, 0x50)
+DW_AT (_byte_stride, 0x51)
+DW_AT (_entry_pc, 0x52)
+DW_AT (_use_UTF8, 0x53)
+DW_AT (_extension, 0x54)
+DW_AT (_ranges, 0x55)
+DW_AT (_trampoline, 0x56)
+DW_AT (_call_column, 0x57)
+DW_AT (_call_file, 0x58)
+DW_AT (_call_line, 0x59)
+DW_AT (_description, 0x5a)
+DW_AT (_binary_scale, 0x5b)
+DW_AT (_decimal_scale, 0x5c)
+DW_AT (_small, 0x5d)
+DW_AT (_decimal_sign, 0x5e)
+DW_AT (_digit_count, 0x5f)
+DW_AT (_picture_string, 0x60)
+DW_AT (_mutable, 0x61)
+DW_AT (_threads_scaled, 0x62)
+DW_AT (_explicit, 0x63)
+DW_AT (_object_pointer, 0x64)
+DW_AT (_endianity, 0x65)
+DW_AT (_elemental, 0x66)
+DW_AT (_pure, 0x67)
+DW_AT (_recursive, 0x68)
+/* DWARF 4.  */
+DW_AT (_signature, 0x69)
+DW_AT (_main_subprogram, 0x6a)
+DW_AT (_data_bit_offset, 0x6b)
+DW_AT (_const_expr, 0x6c)
+DW_AT (_enum_class, 0x6d)
+DW_AT (_linkage_name, 0x6e)
+
+DW_AT_DUP (_lo_user, 0x2000)	/* Implementation-defined range start.  */
+DW_AT_DUP (_hi_user, 0x3fff)	/* Implementation-defined range end.  */
+
+/* SGI/MIPS extensions.  */
+DW_AT (_MIPS_fde, 0x2001)
+DW_AT (_MIPS_loop_begin, 0x2002)
+DW_AT (_MIPS_tail_loop_begin, 0x2003)
+DW_AT (_MIPS_epilog_begin, 0x2004)
+DW_AT (_MIPS_loop_unroll_factor, 0x2005)
+DW_AT (_MIPS_software_pipeline_depth, 0x2006)
+DW_AT (_MIPS_linkage_name, 0x2007)
+DW_AT (_MIPS_stride, 0x2008)
+DW_AT (_MIPS_abstract_name, 0x2009)
+DW_AT (_MIPS_clone_origin, 0x200a)
+DW_AT (_MIPS_has_inlines, 0x200b)
+/* HP extensions.  */
+DW_AT (_HP_block_index, 0x2000)
+DW_AT_DUP (_HP_unmodifiable, 0x2001) /* Same as DW_AT_MIPS_fde.  */
+DW_AT_DUP (_HP_prologue, 0x2005) /* Same as DW_AT_MIPS_loop_unroll.  */
+DW_AT_DUP (_HP_epilogue, 0x2008) /* Same as DW_AT_MIPS_stride.  */
+DW_AT (_HP_actuals_stmt_list, 0x2010)
+DW_AT (_HP_proc_per_section, 0x2011)
+DW_AT (_HP_raw_data_ptr, 0x2012)
+DW_AT (_HP_pass_by_reference, 0x2013)
+DW_AT (_HP_opt_level, 0x2014)
+DW_AT (_HP_prof_version_id, 0x2015)
+DW_AT (_HP_opt_flags, 0x2016)
+DW_AT (_HP_cold_region_low_pc, 0x2017)
+DW_AT (_HP_cold_region_high_pc, 0x2018)
+DW_AT (_HP_all_variables_modifiable, 0x2019)
+DW_AT (_HP_linkage_name, 0x201a)
+DW_AT (_HP_prof_flags, 0x201b)  /* In comp unit of procs_info for -g.  */
+DW_AT (_HP_unit_name, 0x201f)
+DW_AT (_HP_unit_size, 0x2020)
+DW_AT (_HP_widened_byte_size, 0x2021)
+DW_AT (_HP_definition_points, 0x2022)
+DW_AT (_HP_default_location, 0x2023)
+DW_AT (_HP_is_result_param, 0x2029)
+
+/* GNU extensions.  */
+DW_AT (_sf_names, 0x2101)
+DW_AT (_src_info, 0x2102)
+DW_AT (_mac_info, 0x2103)
+DW_AT (_src_coords, 0x2104)
+DW_AT (_body_begin, 0x2105)
+DW_AT (_body_end, 0x2106)
+DW_AT (_GNU_vector, 0x2107)
+/* Thread-safety annotations.
+   See http://gcc.gnu.org/wiki/ThreadSafetyAnnotation .  */
+DW_AT (_GNU_guarded_by, 0x2108)
+DW_AT (_GNU_pt_guarded_by, 0x2109)
+DW_AT (_GNU_guarded, 0x210a)
+DW_AT (_GNU_pt_guarded, 0x210b)
+DW_AT (_GNU_locks_excluded, 0x210c)
+DW_AT (_GNU_exclusive_locks_required, 0x210d)
+DW_AT (_GNU_shared_locks_required, 0x210e)
+/* One-definition rule violation detection.
+   See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo .  */
+DW_AT (_GNU_odr_signature, 0x210f)
+/* Template template argument name.
+   See http://gcc.gnu.org/wiki/TemplateParmsDwarf .  */
+DW_AT (_GNU_template_name, 0x2110)
+/* The GNU call site extension.
+   See http://www.dwarfstd.org/ShowIssue.php?issue=100909.2&type=open .  */
+DW_AT (_GNU_call_site_value, 0x2111)
+DW_AT (_GNU_call_site_data_value, 0x2112)
+DW_AT (_GNU_call_site_target, 0x2113)
+DW_AT (_GNU_call_site_target_clobbered, 0x2114)
+DW_AT (_GNU_tail_call, 0x2115)
+DW_AT (_GNU_all_tail_call_sites, 0x2116)
+DW_AT (_GNU_all_call_sites, 0x2117)
+DW_AT (_GNU_all_source_call_sites, 0x2118)
+/* Section offset into .debug_macro section.  */
+DW_AT (_GNU_macros, 0x2119)
+/* Extensions for Fission.  See http://gcc.gnu.org/wiki/DebugFission.  */
+DW_AT (_GNU_dwo_name, 0x2130)
+DW_AT (_GNU_dwo_id, 0x2131)
+DW_AT (_GNU_ref_base, 0x2132)
+DW_AT (_GNU_addr_base, 0x2133)
+DW_AT (_GNU_pubnames, 0x2134)
+DW_AT (_GNU_pubtypes, 0x2135)
+/* VMS extensions.  */
+DW_AT (_VMS_rtnbeg_pd_address, 0x2201)
+/* GNAT extensions.  */
+/* GNAT descriptive type.
+   See http://gcc.gnu.org/wiki/DW_AT_GNAT_descriptive_type .  */
+DW_AT (_use_GNAT_descriptive_type, 0x2301)
+DW_AT (_GNAT_descriptive_type, 0x2302)
+/* UPC extension.  */
+DW_AT (_upc_threads_scaled, 0x3210)
+/* PGI (STMicroelectronics) extensions.  */
+DW_AT (_PGI_lbase, 0x3a00)
+DW_AT (_PGI_soffset, 0x3a01)
+DW_AT (_PGI_lstride, 0x3a02)
+DW_END_AT
+
+DW_FIRST_OP (_addr, 0x03)
+DW_OP (_deref, 0x06)
+DW_OP (_const1u, 0x08)
+DW_OP (_const1s, 0x09)
+DW_OP (_const2u, 0x0a)
+DW_OP (_const2s, 0x0b)
+DW_OP (_const4u, 0x0c)
+DW_OP (_const4s, 0x0d)
+DW_OP (_const8u, 0x0e)
+DW_OP (_const8s, 0x0f)
+DW_OP (_constu, 0x10)
+DW_OP (_consts, 0x11)
+DW_OP (_dup, 0x12)
+DW_OP (_drop, 0x13)
+DW_OP (_over, 0x14)
+DW_OP (_pick, 0x15)
+DW_OP (_swap, 0x16)
+DW_OP (_rot, 0x17)
+DW_OP (_xderef, 0x18)
+DW_OP (_abs, 0x19)
+DW_OP (_and, 0x1a)
+DW_OP (_div, 0x1b)
+DW_OP (_minus, 0x1c)
+DW_OP (_mod, 0x1d)
+DW_OP (_mul, 0x1e)
+DW_OP (_neg, 0x1f)
+DW_OP (_not, 0x20)
+DW_OP (_or, 0x21)
+DW_OP (_plus, 0x22)
+DW_OP (_plus_uconst, 0x23)
+DW_OP (_shl, 0x24)
+DW_OP (_shr, 0x25)
+DW_OP (_shra, 0x26)
+DW_OP (_xor, 0x27)
+DW_OP (_bra, 0x28)
+DW_OP (_eq, 0x29)
+DW_OP (_ge, 0x2a)
+DW_OP (_gt, 0x2b)
+DW_OP (_le, 0x2c)
+DW_OP (_lt, 0x2d)
+DW_OP (_ne, 0x2e)
+DW_OP (_skip, 0x2f)
+DW_OP (_lit0, 0x30)
+DW_OP (_lit1, 0x31)
+DW_OP (_lit2, 0x32)
+DW_OP (_lit3, 0x33)
+DW_OP (_lit4, 0x34)
+DW_OP (_lit5, 0x35)
+DW_OP (_lit6, 0x36)
+DW_OP (_lit7, 0x37)
+DW_OP (_lit8, 0x38)
+DW_OP (_lit9, 0x39)
+DW_OP (_lit10, 0x3a)
+DW_OP (_lit11, 0x3b)
+DW_OP (_lit12, 0x3c)
+DW_OP (_lit13, 0x3d)
+DW_OP (_lit14, 0x3e)
+DW_OP (_lit15, 0x3f)
+DW_OP (_lit16, 0x40)
+DW_OP (_lit17, 0x41)
+DW_OP (_lit18, 0x42)
+DW_OP (_lit19, 0x43)
+DW_OP (_lit20, 0x44)
+DW_OP (_lit21, 0x45)
+DW_OP (_lit22, 0x46)
+DW_OP (_lit23, 0x47)
+DW_OP (_lit24, 0x48)
+DW_OP (_lit25, 0x49)
+DW_OP (_lit26, 0x4a)
+DW_OP (_lit27, 0x4b)
+DW_OP (_lit28, 0x4c)
+DW_OP (_lit29, 0x4d)
+DW_OP (_lit30, 0x4e)
+DW_OP (_lit31, 0x4f)
+DW_OP (_reg0, 0x50)
+DW_OP (_reg1, 0x51)
+DW_OP (_reg2, 0x52)
+DW_OP (_reg3, 0x53)
+DW_OP (_reg4, 0x54)
+DW_OP (_reg5, 0x55)
+DW_OP (_reg6, 0x56)
+DW_OP (_reg7, 0x57)
+DW_OP (_reg8, 0x58)
+DW_OP (_reg9, 0x59)
+DW_OP (_reg10, 0x5a)
+DW_OP (_reg11, 0x5b)
+DW_OP (_reg12, 0x5c)
+DW_OP (_reg13, 0x5d)
+DW_OP (_reg14, 0x5e)
+DW_OP (_reg15, 0x5f)
+DW_OP (_reg16, 0x60)
+DW_OP (_reg17, 0x61)
+DW_OP (_reg18, 0x62)
+DW_OP (_reg19, 0x63)
+DW_OP (_reg20, 0x64)
+DW_OP (_reg21, 0x65)
+DW_OP (_reg22, 0x66)
+DW_OP (_reg23, 0x67)
+DW_OP (_reg24, 0x68)
+DW_OP (_reg25, 0x69)
+DW_OP (_reg26, 0x6a)
+DW_OP (_reg27, 0x6b)
+DW_OP (_reg28, 0x6c)
+DW_OP (_reg29, 0x6d)
+DW_OP (_reg30, 0x6e)
+DW_OP (_reg31, 0x6f)
+DW_OP (_breg0, 0x70)
+DW_OP (_breg1, 0x71)
+DW_OP (_breg2, 0x72)
+DW_OP (_breg3, 0x73)
+DW_OP (_breg4, 0x74)
+DW_OP (_breg5, 0x75)
+DW_OP (_breg6, 0x76)
+DW_OP (_breg7, 0x77)
+DW_OP (_breg8, 0x78)
+DW_OP (_breg9, 0x79)
+DW_OP (_breg10, 0x7a)
+DW_OP (_breg11, 0x7b)
+DW_OP (_breg12, 0x7c)
+DW_OP (_breg13, 0x7d)
+DW_OP (_breg14, 0x7e)
+DW_OP (_breg15, 0x7f)
+DW_OP (_breg16, 0x80)
+DW_OP (_breg17, 0x81)
+DW_OP (_breg18, 0x82)
+DW_OP (_breg19, 0x83)
+DW_OP (_breg20, 0x84)
+DW_OP (_breg21, 0x85)
+DW_OP (_breg22, 0x86)
+DW_OP (_breg23, 0x87)
+DW_OP (_breg24, 0x88)
+DW_OP (_breg25, 0x89)
+DW_OP (_breg26, 0x8a)
+DW_OP (_breg27, 0x8b)
+DW_OP (_breg28, 0x8c)
+DW_OP (_breg29, 0x8d)
+DW_OP (_breg30, 0x8e)
+DW_OP (_breg31, 0x8f)
+DW_OP (_regx, 0x90)
+DW_OP (_fbreg, 0x91)
+DW_OP (_bregx, 0x92)
+DW_OP (_piece, 0x93)
+DW_OP (_deref_size, 0x94)
+DW_OP (_xderef_size, 0x95)
+DW_OP (_nop, 0x96)
+/* DWARF 3 extensions.  */
+DW_OP (_push_object_address, 0x97)
+DW_OP (_call2, 0x98)
+DW_OP (_call4, 0x99)
+DW_OP (_call_ref, 0x9a)
+DW_OP (_form_tls_address, 0x9b)
+DW_OP (_call_frame_cfa, 0x9c)
+DW_OP (_bit_piece, 0x9d)
+
+/* DWARF 4 extensions.  */
+DW_OP (_implicit_value, 0x9e)
+DW_OP (_stack_value, 0x9f)
+
+DW_OP_DUP (_lo_user, 0xe0)	/* Implementation-defined range start.  */
+DW_OP_DUP (_hi_user, 0xff)	/* Implementation-defined range end.  */
+
+/* GNU extensions.  */
+DW_OP (_GNU_push_tls_address, 0xe0)
+/* The following is for marking variables that are uninitialized.  */
+DW_OP (_GNU_uninit, 0xf0)
+DW_OP (_GNU_encoded_addr, 0xf1)
+/* The GNU implicit pointer extension.
+   See http://www.dwarfstd.org/ShowIssue.php?issue=100831.1&type=open .  */
+DW_OP (_GNU_implicit_pointer, 0xf2)
+/* The GNU entry value extension.
+   See http://www.dwarfstd.org/ShowIssue.php?issue=100909.1&type=open .  */
+DW_OP (_GNU_entry_value, 0xf3)
+/* The GNU typed stack extension.
+   See http://www.dwarfstd.org/doc/040408.1.html .  */
+DW_OP (_GNU_const_type, 0xf4)
+DW_OP (_GNU_regval_type, 0xf5)
+DW_OP (_GNU_deref_type, 0xf6)
+DW_OP (_GNU_convert, 0xf7)
+DW_OP (_GNU_reinterpret, 0xf9)
+/* The GNU parameter ref extension.  */
+DW_OP (_GNU_parameter_ref, 0xfa)
+/* HP extensions.  */
+DW_OP_DUP (_HP_unknown, 0xe0) /* Ouch, the same as GNU_push_tls_address.  */
+DW_OP (_HP_is_value, 0xe1)
+DW_OP (_HP_fltconst4, 0xe2)
+DW_OP (_HP_fltconst8, 0xe3)
+DW_OP (_HP_mod_range, 0xe4)
+DW_OP (_HP_unmod_range, 0xe5)
+DW_OP (_HP_tls, 0xe6)
+/* PGI (STMicroelectronics) extensions.  */
+DW_OP (_PGI_omp_thread_num, 0xf8)
+DW_END_OP
+
+DW_FIRST_ATE (_void, 0x0)
+DW_ATE (_address, 0x1)
+DW_ATE (_boolean, 0x2)
+DW_ATE (_complex_float, 0x3)
+DW_ATE (_float, 0x4)
+DW_ATE (_signed, 0x5)
+DW_ATE (_signed_char, 0x6)
+DW_ATE (_unsigned, 0x7)
+DW_ATE (_unsigned_char, 0x8)
+/* DWARF 3.  */
+DW_ATE (_imaginary_float, 0x9)
+DW_ATE (_packed_decimal, 0xa)
+DW_ATE (_numeric_string, 0xb)
+DW_ATE (_edited, 0xc)
+DW_ATE (_signed_fixed, 0xd)
+DW_ATE (_unsigned_fixed, 0xe)
+DW_ATE (_decimal_float, 0xf)
+/* DWARF 4.  */
+DW_ATE (_UTF, 0x10)
+
+DW_ATE_DUP (_lo_user, 0x80)
+DW_ATE_DUP (_hi_user, 0xff)
+
+/* HP extensions.  */
+DW_ATE (_HP_float80, 0x80) /* Floating-point (80 bit).  */
+DW_ATE (_HP_complex_float80, 0x81) /* Complex floating-point (80 bit).  */
+DW_ATE (_HP_float128, 0x82) /* Floating-point (128 bit).  */
+DW_ATE (_HP_complex_float128, 0x83) /* Complex fp (128 bit).  */
+DW_ATE (_HP_floathpintel, 0x84) /* Floating-point (82 bit IA64).  */
+DW_ATE (_HP_imaginary_float80, 0x85)
+DW_ATE (_HP_imaginary_float128, 0x86)
+DW_ATE (_HP_VAX_float, 0x88) /* F or G floating.  */
+DW_ATE (_HP_VAX_float_d, 0x89) /* D floating.  */
+DW_ATE (_HP_packed_decimal, 0x8a) /* Cobol.  */
+DW_ATE (_HP_zoned_decimal, 0x8b) /* Cobol.  */
+DW_ATE (_HP_edited, 0x8c) /* Cobol.  */
+DW_ATE (_HP_signed_fixed, 0x8d) /* Cobol.  */
+DW_ATE (_HP_unsigned_fixed, 0x8e) /* Cobol.  */
+DW_ATE (_HP_VAX_complex_float, 0x8f) /* F or G floating complex.  */
+DW_ATE (_HP_VAX_complex_float_d, 0x90) /* D floating complex.  */
+
+DW_END_ATE
+
+DW_FIRST_CFA (_advance_loc, 0x40)
+DW_CFA (_offset, 0x80)
+DW_CFA (_restore, 0xc0)
+DW_CFA (_nop, 0x00)
+DW_CFA (_set_loc, 0x01)
+DW_CFA (_advance_loc1, 0x02)
+DW_CFA (_advance_loc2, 0x03)
+DW_CFA (_advance_loc4, 0x04)
+DW_CFA (_offset_extended, 0x05)
+DW_CFA (_restore_extended, 0x06)
+DW_CFA (_undefined, 0x07)
+DW_CFA (_same_value, 0x08)
+DW_CFA (_register, 0x09)
+DW_CFA (_remember_state, 0x0a)
+DW_CFA (_restore_state, 0x0b)
+DW_CFA (_def_cfa, 0x0c)
+DW_CFA (_def_cfa_register, 0x0d)
+DW_CFA (_def_cfa_offset, 0x0e)
+/* DWARF 3.  */
+DW_CFA (_def_cfa_expression, 0x0f)
+DW_CFA (_expression, 0x10)
+DW_CFA (_offset_extended_sf, 0x11)
+DW_CFA (_def_cfa_sf, 0x12)
+DW_CFA (_def_cfa_offset_sf, 0x13)
+DW_CFA (_val_offset, 0x14)
+DW_CFA (_val_offset_sf, 0x15)
+DW_CFA (_val_expression, 0x16)
+
+DW_CFA (_lo_user, 0x1c)
+DW_CFA (_hi_user, 0x3f)
+
+/* SGI/MIPS specific.  */
+DW_CFA (_MIPS_advance_loc8, 0x1d)
+/* GNU extensions.  */
+DW_CFA (_GNU_window_save, 0x2d)
+DW_CFA (_GNU_args_size, 0x2e)
+DW_CFA (_GNU_negative_offset_extended, 0x2f)
+
+DW_END_CFA
diff --git a/include/dwarf2.h b/include/dwarf2.h
index 8c0c9ed..43f0061 100644
--- a/include/dwarf2.h
+++ b/include/dwarf2.h
@@ -1,7 +1,7 @@ 
 /* Declarations and definitions of codes relating to the DWARF2 and
    DWARF3 symbolic debugging information formats.
    Copyright (C) 1992, 1993, 1995, 1996, 1997, 1999, 2000, 2001, 2002,
-   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
    Free Software Foundation, Inc.
 
    Written by Gary Funck (gary@intrepid.com) The Ada Joint Program
@@ -41,599 +41,71 @@ 
    This file also now contains definitions from the DWARF 3 specification
    published Dec 20, 2005, available from: http://dwarf.freestandards.org.  */
 
-/* This file is shared between GCC and GDB, and should not contain
-   prototypes.  */
-
 #ifndef _DWARF2_H
 #define _DWARF2_H
 
-/* Tag names and codes.  */
-enum dwarf_tag
-  {
-    DW_TAG_padding = 0x00,
-    DW_TAG_array_type = 0x01,
-    DW_TAG_class_type = 0x02,
-    DW_TAG_entry_point = 0x03,
-    DW_TAG_enumeration_type = 0x04,
-    DW_TAG_formal_parameter = 0x05,
-    DW_TAG_imported_declaration = 0x08,
-    DW_TAG_label = 0x0a,
-    DW_TAG_lexical_block = 0x0b,
-    DW_TAG_member = 0x0d,
-    DW_TAG_pointer_type = 0x0f,
-    DW_TAG_reference_type = 0x10,
-    DW_TAG_compile_unit = 0x11,
-    DW_TAG_string_type = 0x12,
-    DW_TAG_structure_type = 0x13,
-    DW_TAG_subroutine_type = 0x15,
-    DW_TAG_typedef = 0x16,
-    DW_TAG_union_type = 0x17,
-    DW_TAG_unspecified_parameters = 0x18,
-    DW_TAG_variant = 0x19,
-    DW_TAG_common_block = 0x1a,
-    DW_TAG_common_inclusion = 0x1b,
-    DW_TAG_inheritance = 0x1c,
-    DW_TAG_inlined_subroutine = 0x1d,
-    DW_TAG_module = 0x1e,
-    DW_TAG_ptr_to_member_type = 0x1f,
-    DW_TAG_set_type = 0x20,
-    DW_TAG_subrange_type = 0x21,
-    DW_TAG_with_stmt = 0x22,
-    DW_TAG_access_declaration = 0x23,
-    DW_TAG_base_type = 0x24,
-    DW_TAG_catch_block = 0x25,
-    DW_TAG_const_type = 0x26,
-    DW_TAG_constant = 0x27,
-    DW_TAG_enumerator = 0x28,
-    DW_TAG_file_type = 0x29,
-    DW_TAG_friend = 0x2a,
-    DW_TAG_namelist = 0x2b,
-    DW_TAG_namelist_item = 0x2c,
-    DW_TAG_packed_type = 0x2d,
-    DW_TAG_subprogram = 0x2e,
-    DW_TAG_template_type_param = 0x2f,
-    DW_TAG_template_value_param = 0x30,
-    DW_TAG_thrown_type = 0x31,
-    DW_TAG_try_block = 0x32,
-    DW_TAG_variant_part = 0x33,
-    DW_TAG_variable = 0x34,
-    DW_TAG_volatile_type = 0x35,
-    /* DWARF 3.  */
-    DW_TAG_dwarf_procedure = 0x36,
-    DW_TAG_restrict_type = 0x37,
-    DW_TAG_interface_type = 0x38,
-    DW_TAG_namespace = 0x39,
-    DW_TAG_imported_module = 0x3a,
-    DW_TAG_unspecified_type = 0x3b,
-    DW_TAG_partial_unit = 0x3c,
-    DW_TAG_imported_unit = 0x3d,
-    DW_TAG_condition = 0x3f,
-    DW_TAG_shared_type = 0x40,
-    /* DWARF 4.  */
-    DW_TAG_type_unit = 0x41,
-    DW_TAG_rvalue_reference_type = 0x42,
-    DW_TAG_template_alias = 0x43,
-
-    DW_TAG_lo_user = 0x4080,
-    DW_TAG_hi_user = 0xffff,
-
-    /* SGI/MIPS Extensions.  */
-    DW_TAG_MIPS_loop = 0x4081,
-
-    /* HP extensions.  See: ftp://ftp.hp.com/pub/lang/tools/WDB/wdb-4.0.tar.gz .  */
-    DW_TAG_HP_array_descriptor = 0x4090,
-    DW_TAG_HP_Bliss_field      = 0x4091,
-    DW_TAG_HP_Bliss_field_set  = 0x4092,
-
-    /* GNU extensions.  */
-    DW_TAG_format_label = 0x4101,	/* For FORTRAN 77 and Fortran 90.  */
-    DW_TAG_function_template = 0x4102,	/* For C++.  */
-    DW_TAG_class_template = 0x4103,	/* For C++.  */
-    DW_TAG_GNU_BINCL = 0x4104,
-    DW_TAG_GNU_EINCL = 0x4105,
-    /* Template template parameter.
-       See http://gcc.gnu.org/wiki/TemplateParmsDwarf .  */
-    DW_TAG_GNU_template_template_param = 0x4106,
-
-    /* Template parameter pack extension, specified at
-       http://wiki.dwarfstd.org/index.php?title=C%2B%2B0x:_Variadic_templates
-       The values of these two TAGS are in the DW_TAG_GNU_* space until the tags
-       are properly part of DWARF 5.  */
-    DW_TAG_GNU_template_parameter_pack = 0x4107,
-    DW_TAG_GNU_formal_parameter_pack = 0x4108,
-    /* The GNU call site extension, specified at
-       http://www.dwarfstd.org/ShowIssue.php?issue=100909.2&type=open .
-       The values of these two TAGS are in the DW_TAG_GNU_* space until the tags
-       are properly part of DWARF 5.  */
-    DW_TAG_GNU_call_site = 0x4109,
-    DW_TAG_GNU_call_site_parameter = 0x410a,
-    /* Extensions for UPC.  See: http://upc.gwu.edu/~upc.  */
-    DW_TAG_upc_shared_type = 0x8765,
-    DW_TAG_upc_strict_type = 0x8766,
-    DW_TAG_upc_relaxed_type = 0x8767,
-    /* PGI (STMicroelectronics) extensions.  No documentation available.  */
-    DW_TAG_PGI_kanji_type      = 0xA000,
-    DW_TAG_PGI_interface_block = 0xA020
-  };
+#define DW_TAG(name, value) , DW_TAG ## name = value
+#define DW_TAG_DUP(name, value) , DW_TAG ## name = value
+#define DW_FORM(name, value) , DW_FORM ## name = value
+#define DW_AT(name, value) , DW_AT ## name = value
+#define DW_AT_DUP(name, value) , DW_AT ## name = value
+#define DW_OP(name, value) , DW_OP ## name = value
+#define DW_OP_DUP(name, value) , DW_OP ## name = value
+#define DW_ATE(name, value) , DW_ATE ## name = value
+#define DW_ATE_DUP(name, value) , DW_ATE ## name = value
+#define DW_CFA(name, value) , DW_CFA ## name = value
+
+#define DW_FIRST_TAG(name, value) enum dwarf_tag { \
+  DW_TAG ## name = value
+#define DW_END_TAG };
+#define DW_FIRST_FORM(name, value) enum dwarf_form { \
+  DW_FORM ## name = value
+#define DW_END_FORM };
+#define DW_FIRST_AT(name, value) enum dwarf_attribute { \
+  DW_AT ## name = value
+#define DW_END_AT };
+#define DW_FIRST_OP(name, value) enum dwarf_location_atom { \
+  DW_OP ## name = value
+#define DW_END_OP };
+#define DW_FIRST_ATE(name, value) enum dwarf_type { \
+  DW_ATE ## name = value
+#define DW_END_ATE };
+#define DW_FIRST_CFA(name, value) enum dwarf_call_frame_info { \
+  DW_CFA ## name = value
+#define DW_END_CFA };
+
+#include "dwarf2.def"
+
+#undef DW_FIRST_TAG
+#undef DW_END_TAG
+#undef DW_FIRST_FORM
+#undef DW_END_FORM
+#undef DW_FIRST_AT
+#undef DW_END_AT
+#undef DW_FIRST_OP
+#undef DW_END_OP
+#undef DW_FIRST_ATE
+#undef DW_END_ATE
+#undef DW_FIRST_CFA
+#undef DW_END_CFA
+
+#undef DW_TAG
+#undef DW_TAG_DUP
+#undef DW_FORM
+#undef DW_AT
+#undef DW_AT_DUP
+#undef DW_OP
+#undef DW_OP_DUP
+#undef DW_ATE
+#undef DW_ATE_DUP
+#undef DW_CFA
 
 /* Flag that tells whether entry has a child or not.  */
 #define DW_children_no   0
 #define	DW_children_yes  1
 
-/* Form names and codes.  */
-enum dwarf_form
-  {
-    DW_FORM_addr = 0x01,
-    DW_FORM_block2 = 0x03,
-    DW_FORM_block4 = 0x04,
-    DW_FORM_data2 = 0x05,
-    DW_FORM_data4 = 0x06,
-    DW_FORM_data8 = 0x07,
-    DW_FORM_string = 0x08,
-    DW_FORM_block = 0x09,
-    DW_FORM_block1 = 0x0a,
-    DW_FORM_data1 = 0x0b,
-    DW_FORM_flag = 0x0c,
-    DW_FORM_sdata = 0x0d,
-    DW_FORM_strp = 0x0e,
-    DW_FORM_udata = 0x0f,
-    DW_FORM_ref_addr = 0x10,
-    DW_FORM_ref1 = 0x11,
-    DW_FORM_ref2 = 0x12,
-    DW_FORM_ref4 = 0x13,
-    DW_FORM_ref8 = 0x14,
-    DW_FORM_ref_udata = 0x15,
-    DW_FORM_indirect = 0x16,
-    /* DWARF 4.  */
-    DW_FORM_sec_offset = 0x17,
-    DW_FORM_exprloc = 0x18,
-    DW_FORM_flag_present = 0x19,
-    DW_FORM_ref_sig8 = 0x20,
-    /* Extensions for Fission.  See http://gcc.gnu.org/wiki/DebugFission.  */
-    DW_FORM_GNU_ref_index = 0x1f00,
-    DW_FORM_GNU_addr_index = 0x1f01,
-    DW_FORM_GNU_str_index = 0x1f02
-  };
-
-/* Attribute names and codes.  */
-enum dwarf_attribute
-  {
-    DW_AT_sibling = 0x01,
-    DW_AT_location = 0x02,
-    DW_AT_name = 0x03,
-    DW_AT_ordering = 0x09,
-    DW_AT_subscr_data = 0x0a,
-    DW_AT_byte_size = 0x0b,
-    DW_AT_bit_offset = 0x0c,
-    DW_AT_bit_size = 0x0d,
-    DW_AT_element_list = 0x0f,
-    DW_AT_stmt_list = 0x10,
-    DW_AT_low_pc = 0x11,
-    DW_AT_high_pc = 0x12,
-    DW_AT_language = 0x13,
-    DW_AT_member = 0x14,
-    DW_AT_discr = 0x15,
-    DW_AT_discr_value = 0x16,
-    DW_AT_visibility = 0x17,
-    DW_AT_import = 0x18,
-    DW_AT_string_length = 0x19,
-    DW_AT_common_reference = 0x1a,
-    DW_AT_comp_dir = 0x1b,
-    DW_AT_const_value = 0x1c,
-    DW_AT_containing_type = 0x1d,
-    DW_AT_default_value = 0x1e,
-    DW_AT_inline = 0x20,
-    DW_AT_is_optional = 0x21,
-    DW_AT_lower_bound = 0x22,
-    DW_AT_producer = 0x25,
-    DW_AT_prototyped = 0x27,
-    DW_AT_return_addr = 0x2a,
-    DW_AT_start_scope = 0x2c,
-    DW_AT_bit_stride = 0x2e,
 #define DW_AT_stride_size   DW_AT_bit_stride  /* Note: The use of DW_AT_stride_size is deprecated.  */
-    DW_AT_upper_bound = 0x2f,
-    DW_AT_abstract_origin = 0x31,
-    DW_AT_accessibility = 0x32,
-    DW_AT_address_class = 0x33,
-    DW_AT_artificial = 0x34,
-    DW_AT_base_types = 0x35,
-    DW_AT_calling_convention = 0x36,
-    DW_AT_count = 0x37,
-    DW_AT_data_member_location = 0x38,
-    DW_AT_decl_column = 0x39,
-    DW_AT_decl_file = 0x3a,
-    DW_AT_decl_line = 0x3b,
-    DW_AT_declaration = 0x3c,
-    DW_AT_discr_list = 0x3d,
-    DW_AT_encoding = 0x3e,
-    DW_AT_external = 0x3f,
-    DW_AT_frame_base = 0x40,
-    DW_AT_friend = 0x41,
-    DW_AT_identifier_case = 0x42,
-    DW_AT_macro_info = 0x43,
-    DW_AT_namelist_items = 0x44,
-    DW_AT_priority = 0x45,
-    DW_AT_segment = 0x46,
-    DW_AT_specification = 0x47,
-    DW_AT_static_link = 0x48,
-    DW_AT_type = 0x49,
-    DW_AT_use_location = 0x4a,
-    DW_AT_variable_parameter = 0x4b,
-    DW_AT_virtuality = 0x4c,
-    DW_AT_vtable_elem_location = 0x4d,
-    /* DWARF 3 values.  */
-    DW_AT_allocated     = 0x4e,
-    DW_AT_associated    = 0x4f,
-    DW_AT_data_location = 0x50,
-    DW_AT_byte_stride   = 0x51,
 #define DW_AT_stride   DW_AT_byte_stride  /* Note: The use of DW_AT_stride is deprecated.  */
-    DW_AT_entry_pc      = 0x52,
-    DW_AT_use_UTF8      = 0x53,
-    DW_AT_extension     = 0x54,
-    DW_AT_ranges        = 0x55,
-    DW_AT_trampoline    = 0x56,
-    DW_AT_call_column   = 0x57,
-    DW_AT_call_file     = 0x58,
-    DW_AT_call_line     = 0x59,
-    DW_AT_description   = 0x5a,
-    DW_AT_binary_scale  = 0x5b,
-    DW_AT_decimal_scale = 0x5c,
-    DW_AT_small         = 0x5d,
-    DW_AT_decimal_sign  = 0x5e,
-    DW_AT_digit_count   = 0x5f,
-    DW_AT_picture_string = 0x60,
-    DW_AT_mutable       = 0x61,
-    DW_AT_threads_scaled = 0x62,
-    DW_AT_explicit      = 0x63,
-    DW_AT_object_pointer = 0x64,
-    DW_AT_endianity     = 0x65,
-    DW_AT_elemental     = 0x66,
-    DW_AT_pure          = 0x67,
-    DW_AT_recursive     = 0x68,
-    /* DWARF 4.  */
-    DW_AT_signature       = 0x69,
-    DW_AT_main_subprogram = 0x6a,
-    DW_AT_data_bit_offset = 0x6b,
-    DW_AT_const_expr      = 0x6c,
-    DW_AT_enum_class      = 0x6d,
-    DW_AT_linkage_name    = 0x6e,
-
-    DW_AT_lo_user = 0x2000,	/* Implementation-defined range start.  */
-    DW_AT_hi_user = 0x3fff,	/* Implementation-defined range end.  */
-
-    /* SGI/MIPS extensions.  */
-    DW_AT_MIPS_fde = 0x2001,
-    DW_AT_MIPS_loop_begin = 0x2002,
-    DW_AT_MIPS_tail_loop_begin = 0x2003,
-    DW_AT_MIPS_epilog_begin = 0x2004,
-    DW_AT_MIPS_loop_unroll_factor = 0x2005,
-    DW_AT_MIPS_software_pipeline_depth = 0x2006,
-    DW_AT_MIPS_linkage_name = 0x2007,
-    DW_AT_MIPS_stride = 0x2008,
-    DW_AT_MIPS_abstract_name = 0x2009,
-    DW_AT_MIPS_clone_origin = 0x200a,
-    DW_AT_MIPS_has_inlines = 0x200b,
-    /* HP extensions.  */
-    DW_AT_HP_block_index         = 0x2000,
-    DW_AT_HP_unmodifiable        = 0x2001, /* Same as DW_AT_MIPS_fde.  */
-    DW_AT_HP_prologue            = 0x2005, /* Same as DW_AT_MIPS_loop_unroll.  */
-    DW_AT_HP_epilogue            = 0x2008, /* Same as DW_AT_MIPS_stride.  */
-    DW_AT_HP_actuals_stmt_list   = 0x2010,
-    DW_AT_HP_proc_per_section    = 0x2011,
-    DW_AT_HP_raw_data_ptr        = 0x2012,
-    DW_AT_HP_pass_by_reference   = 0x2013,
-    DW_AT_HP_opt_level           = 0x2014,
-    DW_AT_HP_prof_version_id     = 0x2015,
-    DW_AT_HP_opt_flags           = 0x2016,
-    DW_AT_HP_cold_region_low_pc  = 0x2017,
-    DW_AT_HP_cold_region_high_pc = 0x2018,
-    DW_AT_HP_all_variables_modifiable = 0x2019,
-    DW_AT_HP_linkage_name        = 0x201a,
-    DW_AT_HP_prof_flags          = 0x201b,  /* In comp unit of procs_info for -g.  */
-    DW_AT_HP_unit_name           = 0x201f,
-    DW_AT_HP_unit_size           = 0x2020,
-    DW_AT_HP_widened_byte_size   = 0x2021,
-    DW_AT_HP_definition_points   = 0x2022,
-    DW_AT_HP_default_location    = 0x2023,
-    DW_AT_HP_is_result_param     = 0x2029,
-
-    /* GNU extensions.  */
-    DW_AT_sf_names   = 0x2101,
-    DW_AT_src_info   = 0x2102,
-    DW_AT_mac_info   = 0x2103,
-    DW_AT_src_coords = 0x2104,
-    DW_AT_body_begin = 0x2105,
-    DW_AT_body_end   = 0x2106,
-    DW_AT_GNU_vector = 0x2107,
-    /* Thread-safety annotations.
-       See http://gcc.gnu.org/wiki/ThreadSafetyAnnotation .  */
-    DW_AT_GNU_guarded_by    = 0x2108,
-    DW_AT_GNU_pt_guarded_by = 0x2109,
-    DW_AT_GNU_guarded       = 0x210a,
-    DW_AT_GNU_pt_guarded    = 0x210b,
-    DW_AT_GNU_locks_excluded = 0x210c,
-    DW_AT_GNU_exclusive_locks_required = 0x210d,
-    DW_AT_GNU_shared_locks_required = 0x210e,
-    /* One-definition rule violation detection.
-       See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo .  */
-    DW_AT_GNU_odr_signature = 0x210f,
-    /* Template template argument name.
-       See http://gcc.gnu.org/wiki/TemplateParmsDwarf .  */
-    DW_AT_GNU_template_name = 0x2110,
-    /* The GNU call site extension.
-       See http://www.dwarfstd.org/ShowIssue.php?issue=100909.2&type=open .  */
-    DW_AT_GNU_call_site_value = 0x2111,
-    DW_AT_GNU_call_site_data_value = 0x2112,
-    DW_AT_GNU_call_site_target = 0x2113,
-    DW_AT_GNU_call_site_target_clobbered = 0x2114,
-    DW_AT_GNU_tail_call = 0x2115,
-    DW_AT_GNU_all_tail_call_sites = 0x2116,
-    DW_AT_GNU_all_call_sites = 0x2117,
-    DW_AT_GNU_all_source_call_sites = 0x2118,
-    /* Section offset into .debug_macro section.  */
-    DW_AT_GNU_macros = 0x2119,
-    /* Extensions for Fission.  See http://gcc.gnu.org/wiki/DebugFission.  */
-    DW_AT_GNU_dwo_name = 0x2130,
-    DW_AT_GNU_dwo_id = 0x2131,
-    DW_AT_GNU_ref_base = 0x2132,
-    DW_AT_GNU_addr_base = 0x2133,
-    DW_AT_GNU_pubnames = 0x2134,
-    DW_AT_GNU_pubtypes = 0x2135,
-    /* VMS extensions.  */
-    DW_AT_VMS_rtnbeg_pd_address = 0x2201,
-    /* GNAT extensions.  */
-    /* GNAT descriptive type.
-       See http://gcc.gnu.org/wiki/DW_AT_GNAT_descriptive_type .  */
-    DW_AT_use_GNAT_descriptive_type = 0x2301,
-    DW_AT_GNAT_descriptive_type	= 0x2302,
-    /* UPC extension.  */
-    DW_AT_upc_threads_scaled = 0x3210,
-    /* PGI (STMicroelectronics) extensions.  */
-    DW_AT_PGI_lbase    = 0x3a00,
-    DW_AT_PGI_soffset  = 0x3a01,
-    DW_AT_PGI_lstride  = 0x3a02
-  };
-
-/* Location atom names and codes.  */
-enum dwarf_location_atom
-  {
-    DW_OP_addr = 0x03,
-    DW_OP_deref = 0x06,
-    DW_OP_const1u = 0x08,
-    DW_OP_const1s = 0x09,
-    DW_OP_const2u = 0x0a,
-    DW_OP_const2s = 0x0b,
-    DW_OP_const4u = 0x0c,
-    DW_OP_const4s = 0x0d,
-    DW_OP_const8u = 0x0e,
-    DW_OP_const8s = 0x0f,
-    DW_OP_constu = 0x10,
-    DW_OP_consts = 0x11,
-    DW_OP_dup = 0x12,
-    DW_OP_drop = 0x13,
-    DW_OP_over = 0x14,
-    DW_OP_pick = 0x15,
-    DW_OP_swap = 0x16,
-    DW_OP_rot = 0x17,
-    DW_OP_xderef = 0x18,
-    DW_OP_abs = 0x19,
-    DW_OP_and = 0x1a,
-    DW_OP_div = 0x1b,
-    DW_OP_minus = 0x1c,
-    DW_OP_mod = 0x1d,
-    DW_OP_mul = 0x1e,
-    DW_OP_neg = 0x1f,
-    DW_OP_not = 0x20,
-    DW_OP_or = 0x21,
-    DW_OP_plus = 0x22,
-    DW_OP_plus_uconst = 0x23,
-    DW_OP_shl = 0x24,
-    DW_OP_shr = 0x25,
-    DW_OP_shra = 0x26,
-    DW_OP_xor = 0x27,
-    DW_OP_bra = 0x28,
-    DW_OP_eq = 0x29,
-    DW_OP_ge = 0x2a,
-    DW_OP_gt = 0x2b,
-    DW_OP_le = 0x2c,
-    DW_OP_lt = 0x2d,
-    DW_OP_ne = 0x2e,
-    DW_OP_skip = 0x2f,
-    DW_OP_lit0 = 0x30,
-    DW_OP_lit1 = 0x31,
-    DW_OP_lit2 = 0x32,
-    DW_OP_lit3 = 0x33,
-    DW_OP_lit4 = 0x34,
-    DW_OP_lit5 = 0x35,
-    DW_OP_lit6 = 0x36,
-    DW_OP_lit7 = 0x37,
-    DW_OP_lit8 = 0x38,
-    DW_OP_lit9 = 0x39,
-    DW_OP_lit10 = 0x3a,
-    DW_OP_lit11 = 0x3b,
-    DW_OP_lit12 = 0x3c,
-    DW_OP_lit13 = 0x3d,
-    DW_OP_lit14 = 0x3e,
-    DW_OP_lit15 = 0x3f,
-    DW_OP_lit16 = 0x40,
-    DW_OP_lit17 = 0x41,
-    DW_OP_lit18 = 0x42,
-    DW_OP_lit19 = 0x43,
-    DW_OP_lit20 = 0x44,
-    DW_OP_lit21 = 0x45,
-    DW_OP_lit22 = 0x46,
-    DW_OP_lit23 = 0x47,
-    DW_OP_lit24 = 0x48,
-    DW_OP_lit25 = 0x49,
-    DW_OP_lit26 = 0x4a,
-    DW_OP_lit27 = 0x4b,
-    DW_OP_lit28 = 0x4c,
-    DW_OP_lit29 = 0x4d,
-    DW_OP_lit30 = 0x4e,
-    DW_OP_lit31 = 0x4f,
-    DW_OP_reg0 = 0x50,
-    DW_OP_reg1 = 0x51,
-    DW_OP_reg2 = 0x52,
-    DW_OP_reg3 = 0x53,
-    DW_OP_reg4 = 0x54,
-    DW_OP_reg5 = 0x55,
-    DW_OP_reg6 = 0x56,
-    DW_OP_reg7 = 0x57,
-    DW_OP_reg8 = 0x58,
-    DW_OP_reg9 = 0x59,
-    DW_OP_reg10 = 0x5a,
-    DW_OP_reg11 = 0x5b,
-    DW_OP_reg12 = 0x5c,
-    DW_OP_reg13 = 0x5d,
-    DW_OP_reg14 = 0x5e,
-    DW_OP_reg15 = 0x5f,
-    DW_OP_reg16 = 0x60,
-    DW_OP_reg17 = 0x61,
-    DW_OP_reg18 = 0x62,
-    DW_OP_reg19 = 0x63,
-    DW_OP_reg20 = 0x64,
-    DW_OP_reg21 = 0x65,
-    DW_OP_reg22 = 0x66,
-    DW_OP_reg23 = 0x67,
-    DW_OP_reg24 = 0x68,
-    DW_OP_reg25 = 0x69,
-    DW_OP_reg26 = 0x6a,
-    DW_OP_reg27 = 0x6b,
-    DW_OP_reg28 = 0x6c,
-    DW_OP_reg29 = 0x6d,
-    DW_OP_reg30 = 0x6e,
-    DW_OP_reg31 = 0x6f,
-    DW_OP_breg0 = 0x70,
-    DW_OP_breg1 = 0x71,
-    DW_OP_breg2 = 0x72,
-    DW_OP_breg3 = 0x73,
-    DW_OP_breg4 = 0x74,
-    DW_OP_breg5 = 0x75,
-    DW_OP_breg6 = 0x76,
-    DW_OP_breg7 = 0x77,
-    DW_OP_breg8 = 0x78,
-    DW_OP_breg9 = 0x79,
-    DW_OP_breg10 = 0x7a,
-    DW_OP_breg11 = 0x7b,
-    DW_OP_breg12 = 0x7c,
-    DW_OP_breg13 = 0x7d,
-    DW_OP_breg14 = 0x7e,
-    DW_OP_breg15 = 0x7f,
-    DW_OP_breg16 = 0x80,
-    DW_OP_breg17 = 0x81,
-    DW_OP_breg18 = 0x82,
-    DW_OP_breg19 = 0x83,
-    DW_OP_breg20 = 0x84,
-    DW_OP_breg21 = 0x85,
-    DW_OP_breg22 = 0x86,
-    DW_OP_breg23 = 0x87,
-    DW_OP_breg24 = 0x88,
-    DW_OP_breg25 = 0x89,
-    DW_OP_breg26 = 0x8a,
-    DW_OP_breg27 = 0x8b,
-    DW_OP_breg28 = 0x8c,
-    DW_OP_breg29 = 0x8d,
-    DW_OP_breg30 = 0x8e,
-    DW_OP_breg31 = 0x8f,
-    DW_OP_regx = 0x90,
-    DW_OP_fbreg = 0x91,
-    DW_OP_bregx = 0x92,
-    DW_OP_piece = 0x93,
-    DW_OP_deref_size = 0x94,
-    DW_OP_xderef_size = 0x95,
-    DW_OP_nop = 0x96,
-    /* DWARF 3 extensions.  */
-    DW_OP_push_object_address = 0x97,
-    DW_OP_call2 = 0x98,
-    DW_OP_call4 = 0x99,
-    DW_OP_call_ref = 0x9a,
-    DW_OP_form_tls_address = 0x9b,
-    DW_OP_call_frame_cfa = 0x9c,
-    DW_OP_bit_piece = 0x9d,
-
-    /* DWARF 4 extensions.  */
-    DW_OP_implicit_value = 0x9e,
-    DW_OP_stack_value = 0x9f,
-
-    DW_OP_lo_user = 0xe0,	/* Implementation-defined range start.  */
-    DW_OP_hi_user = 0xff,	/* Implementation-defined range end.  */
-
-    /* GNU extensions.  */
-    DW_OP_GNU_push_tls_address = 0xe0,
-    /* The following is for marking variables that are uninitialized.  */
-    DW_OP_GNU_uninit     = 0xf0,
-    DW_OP_GNU_encoded_addr = 0xf1,
-    /* The GNU implicit pointer extension.
-       See http://www.dwarfstd.org/ShowIssue.php?issue=100831.1&type=open .  */
-    DW_OP_GNU_implicit_pointer = 0xf2,
-    /* The GNU entry value extension.
-       See http://www.dwarfstd.org/ShowIssue.php?issue=100909.1&type=open .  */
-    DW_OP_GNU_entry_value = 0xf3,
-    /* The GNU typed stack extension.
-       See http://www.dwarfstd.org/doc/040408.1.html .  */
-    DW_OP_GNU_const_type = 0xf4,
-    DW_OP_GNU_regval_type = 0xf5,
-    DW_OP_GNU_deref_type = 0xf6,
-    DW_OP_GNU_convert = 0xf7,
-    DW_OP_GNU_reinterpret = 0xf9,
-    /* The GNU parameter ref extension.  */
-    DW_OP_GNU_parameter_ref = 0xfa,
-    /* HP extensions.  */
-    DW_OP_HP_unknown     = 0xe0, /* Ouch, the same as GNU_push_tls_address.  */
-    DW_OP_HP_is_value    = 0xe1,
-    DW_OP_HP_fltconst4   = 0xe2,
-    DW_OP_HP_fltconst8   = 0xe3,
-    DW_OP_HP_mod_range   = 0xe4,
-    DW_OP_HP_unmod_range = 0xe5,
-    DW_OP_HP_tls         = 0xe6,
-    /* PGI (STMicroelectronics) extensions.  */
-    DW_OP_PGI_omp_thread_num = 0xf8
-  };
-
-/* Type encodings.  */
-enum dwarf_type
-  {
-    DW_ATE_void = 0x0,
-    DW_ATE_address = 0x1,
-    DW_ATE_boolean = 0x2,
-    DW_ATE_complex_float = 0x3,
-    DW_ATE_float = 0x4,
-    DW_ATE_signed = 0x5,
-    DW_ATE_signed_char = 0x6,
-    DW_ATE_unsigned = 0x7,
-    DW_ATE_unsigned_char = 0x8,
-    /* DWARF 3.  */
-    DW_ATE_imaginary_float = 0x9,
-    DW_ATE_packed_decimal = 0xa,
-    DW_ATE_numeric_string = 0xb,
-    DW_ATE_edited = 0xc,
-    DW_ATE_signed_fixed = 0xd,
-    DW_ATE_unsigned_fixed = 0xe,
-    DW_ATE_decimal_float = 0xf,
-    /* DWARF 4.  */
-    DW_ATE_UTF = 0x10,
-
-    DW_ATE_lo_user = 0x80,
-    DW_ATE_hi_user = 0xff,
-
-    /* HP extensions.  */
-    DW_ATE_HP_float80             = 0x80, /* Floating-point (80 bit).  */
-    DW_ATE_HP_complex_float80     = 0x81, /* Complex floating-point (80 bit).  */
-    DW_ATE_HP_float128            = 0x82, /* Floating-point (128 bit).  */
-    DW_ATE_HP_complex_float128    = 0x83, /* Complex fp (128 bit).  */
-    DW_ATE_HP_floathpintel        = 0x84, /* Floating-point (82 bit IA64).  */
-    DW_ATE_HP_imaginary_float80   = 0x85,
-    DW_ATE_HP_imaginary_float128  = 0x86,
-    DW_ATE_HP_VAX_float           = 0x88, /* F or G floating.  */
-    DW_ATE_HP_VAX_float_d         = 0x89, /* D floating.  */
-    DW_ATE_HP_packed_decimal      = 0x8a, /* Cobol.  */
-    DW_ATE_HP_zoned_decimal       = 0x8b, /* Cobol.  */
-    DW_ATE_HP_edited              = 0x8c, /* Cobol.  */
-    DW_ATE_HP_signed_fixed        = 0x8d, /* Cobol.  */
-    DW_ATE_HP_unsigned_fixed      = 0x8e, /* Cobol.  */
-    DW_ATE_HP_VAX_complex_float   = 0x8f, /* F or G floating complex.  */
-    DW_ATE_HP_VAX_complex_float_d = 0x90  /* D floating complex.  */
-  };
 
 /* Decimal sign encodings.  */
 enum dwarf_decimal_sign_encoding
@@ -787,48 +259,6 @@  enum dwarf_line_number_hp_sfc_ops
     DW_LNE_HP_SFC_associate = 3
   };
 
-/* Call frame information.  */
-enum dwarf_call_frame_info
-  {
-    DW_CFA_advance_loc = 0x40,
-    DW_CFA_offset = 0x80,
-    DW_CFA_restore = 0xc0,
-    DW_CFA_nop = 0x00,
-    DW_CFA_set_loc = 0x01,
-    DW_CFA_advance_loc1 = 0x02,
-    DW_CFA_advance_loc2 = 0x03,
-    DW_CFA_advance_loc4 = 0x04,
-    DW_CFA_offset_extended = 0x05,
-    DW_CFA_restore_extended = 0x06,
-    DW_CFA_undefined = 0x07,
-    DW_CFA_same_value = 0x08,
-    DW_CFA_register = 0x09,
-    DW_CFA_remember_state = 0x0a,
-    DW_CFA_restore_state = 0x0b,
-    DW_CFA_def_cfa = 0x0c,
-    DW_CFA_def_cfa_register = 0x0d,
-    DW_CFA_def_cfa_offset = 0x0e,
-    /* DWARF 3.  */
-    DW_CFA_def_cfa_expression = 0x0f,
-    DW_CFA_expression = 0x10,
-    DW_CFA_offset_extended_sf = 0x11,
-    DW_CFA_def_cfa_sf = 0x12,
-    DW_CFA_def_cfa_offset_sf = 0x13,
-    DW_CFA_val_offset = 0x14,
-    DW_CFA_val_offset_sf = 0x15,
-    DW_CFA_val_expression = 0x16,
-
-    DW_CFA_lo_user = 0x1c,
-    DW_CFA_hi_user = 0x3f,
-
-    /* SGI/MIPS specific.  */
-    DW_CFA_MIPS_advance_loc8 = 0x1d,
-    /* GNU extensions.  */
-    DW_CFA_GNU_window_save = 0x2d,
-    DW_CFA_GNU_args_size = 0x2e,
-    DW_CFA_GNU_negative_offset_extended = 0x2f
-  };
-
 #define DW_CIE_ID	  0xffffffff
 #define DW64_CIE_ID	  0xffffffffffffffffULL
 #define DW_CIE_VERSION	  1
@@ -930,4 +360,29 @@  enum dwarf_macro_record_type
 
 #define DW_EH_PE_indirect	0x80
 
+
+/* Return the name of a DW_TAG_ constant, or NULL if the value is not
+   recognized.  */
+extern const char *get_DW_TAG_name (unsigned int tag);
+
+/* Return the name of a DW_AT_ constant, or NULL if the value is not
+   recognized.  */
+extern const char *get_DW_AT_name (unsigned int attr);
+
+/* Return the name of a DW_FORM_ constant, or NULL if the value is not
+   recognized.  */
+extern const char *get_DW_FORM_name (unsigned int form);
+
+/* Return the name of a DW_OP_ constant, or NULL if the value is not
+   recognized.  */
+extern const char *get_DW_OP_name (unsigned int op);
+
+/* Return the name of a DW_ATE_ constant, or NULL if the value is not
+   recognized.  */
+extern const char *get_DW_ATE_name (unsigned int enc);
+
+/* Return the name of a DW_CFA_ constant, or NULL if the value is not
+   recognized.  */
+extern const char *get_DW_CFA_name (unsigned int opc);
+
 #endif /* _DWARF2_H */
diff --git a/libiberty/Makefile.in b/libiberty/Makefile.in
index 5280bc1..0a5da31 100644
--- a/libiberty/Makefile.in
+++ b/libiberty/Makefile.in
@@ -2,7 +2,7 @@ 
 # Originally written by K. Richard Pixley <rich@cygnus.com>.
 #
 # Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-# 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
 # Free Software Foundation
 #
 # This file is part of the libiberty library.
@@ -126,7 +126,7 @@  CFILES = alloca.c argv.c asprintf.c atexit.c				\
 	basename.c bcmp.c bcopy.c bsearch.c bzero.c			\
 	calloc.c choose-temp.c clock.c concat.c cp-demangle.c		\
 	 cp-demint.c cplus-dem.c crc32.c				\
-	dyn-string.c							\
+	dwarfnames.c dyn-string.c					\
 	fdmatch.c ffs.c fibheap.c filename_cmp.c floatformat.c		\
 	fnmatch.c fopen_unlocked.c					\
 	getcwd.c getopt.c getopt1.c getpagesize.c getpwd.c getruntime.c	\
@@ -166,7 +166,8 @@  REQUIRED_OFILES =							\
 	./md5.$(objext) ./sha1.$(objext) ./alloca.$(objext)		\
 	./argv.$(objext)						\
 	./choose-temp.$(objext) ./concat.$(objext)			\
-	./cp-demint.$(objext) ./crc32.$(objext) ./dyn-string.$(objext)	\
+	./cp-demint.$(objext) ./crc32.$(objext)				\
+	./dwarfnames.$(objext) ./dyn-string.$(objext)			\
 	./fdmatch.$(objext) ./fibheap.$(objext)				\
 	./filename_cmp.$(objext) ./floatformat.$(objext)		\
 	./fnmatch.$(objext) ./fopen_unlocked.$(objext)			\
@@ -621,6 +622,13 @@  $(CONFIGURED_OFILES): stamp-picdir
 	else true; fi
 	$(COMPILE.c) $(srcdir)/crc32.c $(OUTPUT_OPTION)
 
+./dwarfnames.$(objext): $(srcdir)/dwarfnames.c $(INCDIR)/dwarf2.h \
+	$(INCDIR)/dwarf2.def
+	if [ x"$(PICFLAG)" != x ]; then \
+	  $(COMPILE.c) $(PICFLAG) $(srcdir)/dwarfnames.c -o pic/$@; \
+	else true; fi
+	$(COMPILE.c) $(srcdir)/dwarfnames.c $(OUTPUT_OPTION)
+
 ./dyn-string.$(objext): $(srcdir)/dyn-string.c config.h $(INCDIR)/ansidecl.h \
 	$(INCDIR)/dyn-string.h $(INCDIR)/libiberty.h
 	if [ x"$(PICFLAG)" != x ]; then \
diff --git a/libiberty/dwarfnames.c b/libiberty/dwarfnames.c
new file mode 100644
index 0000000..56bd68e
--- /dev/null
+++ b/libiberty/dwarfnames.c
@@ -0,0 +1,99 @@ 
+/* Names of various DWARF tags.
+   Copyright (C) 2012 Free Software Foundation, Inc.
+
+This file is part of GNU CC.
+   
+GNU CC 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.
+
+In addition to the permissions in the GNU General Public License, the
+Free Software Foundation gives you unlimited permission to link the
+compiled version of this file into combinations with other programs,
+and to distribute those combinations without any restriction coming
+from the use of this file.  (The General Public License restrictions
+do apply in other respects; for example, they cover modification of
+the file, and distribution when not linked into a combined
+executable.)
+
+GNU CC 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 GNU CC; see the file COPYING.  If not, write to
+the Free Software Foundation, 51 Franklin Street - Fifth Floor,
+Boston, MA 02110-1301, USA.  */
+
+/* Just to ensure the prototypes are correct.  */
+#include "dwarf2.h"
+
+#define DW_FIRST_TAG(name, value) \
+  const char *get_DW_TAG_name (unsigned int tag)	\
+  { switch (tag) { \
+  DW_TAG (name, value)
+#define DW_END_TAG } return 0; }
+#define DW_FIRST_FORM(name, value) \
+  const char *get_DW_FORM_name (unsigned int form)	\
+  { switch (form) { \
+  DW_FORM (name, value)
+#define DW_END_FORM } return 0; }
+#define DW_FIRST_AT(name, value) \
+  const char *get_DW_AT_name (unsigned int attr) {	\
+  switch (attr) { \
+  DW_AT (name, value)
+#define DW_END_AT } return 0; }
+#define DW_FIRST_OP(name, value) \
+  const char *get_DW_OP_name (unsigned int op) {	\
+  switch (op) { \
+  DW_OP (name, value)
+#define DW_END_OP } return 0; }
+#define DW_FIRST_ATE(name, value)			\
+  const char *get_DW_ATE_name (unsigned int enc) {	\
+  switch (enc) { \
+  DW_ATE (name, value)
+#define DW_END_ATE } return 0; }
+#define DW_FIRST_CFA(name, value) \
+  const char *get_DW_CFA_name (unsigned int opc) {	\
+  switch (opc) {					\
+  DW_CFA (name, value)
+#define DW_END_CFA } return 0; }
+
+#define DW_TAG(name, value) case value: return "DW_TAG" # name ;
+#define DW_TAG_DUP(name, value)
+#define DW_FORM(name, value) case value: return "DW_FORM" # name ;
+#define DW_AT(name, value) case value: return "DW_AT" # name ;
+#define DW_AT_DUP(name, value)
+#define DW_OP(name, value) case value: return "DW_OP" # name ;
+#define DW_OP_DUP(name, value)
+#define DW_ATE(name, value) case value: return "DW_ATE" # name ;
+#define DW_ATE_DUP(name, value)
+#define DW_CFA(name, value) case value: return "DW_CFA" # name ;
+
+#include "dwarf2.def"
+
+#undef DW_FIRST_TAG
+#undef DW_END_TAG
+#undef DW_FIRST_FORM
+#undef DW_END_FORM
+#undef DW_FIRST_AT
+#undef DW_END_AT
+#undef DW_FIRST_OP
+#undef DW_END_OP
+#undef DW_FIRST_ATE
+#undef DW_END_ATE
+#undef DW_FIRST_CFA
+#undef DW_END_CFA
+
+#undef DW_TAG
+#undef DW_TAG_DUP
+#undef DW_FORM
+#undef DW_AT
+#undef DW_AT_DUP
+#undef DW_OP
+#undef DW_OP_DUP
+#undef DW_ATE
+#undef DW_ATE_DUP
+#undef DW_CFA