dwarflint: Devirtualize form and attribute

diff --git a/dwarflint/dwarf_2.cc b/dwarflint/dwarf_2.cc
index 3fc1e71c1e3e5c8ef100707e52a4532f8ec4a672..e29a5c6703734d22f7c6962a95ac47fd1b7a6e1e 100644 (file)
--- a/dwarflint/dwarf_2.cc
+++ b/dwarflint/dwarf_2.cc
@@ -34,67 +34,66 @@ namespace
   {
     dwarf_2_attributes ()
     {
-      add (new ref_attribute (DW_AT_sibling));
-      add (new const_or_block_attribute (DW_AT_location));
-      add (new string_attribute (DW_AT_name));
-      add (new const_attribute (DW_AT_ordering));
-      add (new const_attribute (DW_AT_byte_size));
-      add (new const_attribute (DW_AT_bit_offset));
-      add (new const_attribute (DW_AT_bit_size));
-      add (new const_attribute (DW_AT_stmt_list));
-      add (new addr_attribute (DW_AT_low_pc));
-      add (new addr_attribute (DW_AT_high_pc));
-      add (new const_attribute (DW_AT_language));
-      add (new ref_attribute (DW_AT_discr));
-      add (new const_attribute (DW_AT_discr_value));
-      add (new const_attribute (DW_AT_visibility));
-      add (new ref_attribute (DW_AT_import));
-      add (new const_or_block_attribute (DW_AT_string_length));
-      add (new ref_attribute (DW_AT_common_reference));
-      add (new string_attribute (DW_AT_comp_dir));
-      add (new basic_attribute (DW_AT_const_value,
-                               dw_class_set (cl_string, cl_constant,
-                                             cl_block)));
-      add (new ref_attribute (DW_AT_containing_type));
-      add (new ref_attribute (DW_AT_default_value));
-      add (new const_attribute (DW_AT_inline));
-      add (new flag_attribute (DW_AT_is_optional));
-      add (new const_or_ref_attribute (DW_AT_lower_bound));
-      add (new string_attribute (DW_AT_producer));
-      add (new flag_attribute (DW_AT_prototyped));
-      add (new const_or_block_attribute (DW_AT_return_addr));
-      add (new const_attribute (DW_AT_start_scope));
-      add (new const_attribute (DW_AT_bit_stride));
-      add (new const_or_ref_attribute (DW_AT_upper_bound));
-      add (new const_attribute (DW_AT_abstract_origin));
-      add (new ref_attribute (DW_AT_accessibility));
-      add (new const_attribute (DW_AT_address_class));
-      add (new flag_attribute (DW_AT_artificial));
-      add (new ref_attribute (DW_AT_base_types));
-      add (new const_attribute (DW_AT_calling_convention));
-      add (new const_or_ref_attribute (DW_AT_count));
-      add (new ref_or_block_attribute (DW_AT_data_member_location));
-      add (new const_attribute (DW_AT_decl_column));
-      add (new const_attribute (DW_AT_decl_file));
-      add (new const_attribute (DW_AT_decl_line));
-      add (new flag_attribute (DW_AT_declaration));
-      add (new block_attribute (DW_AT_discr_list));
-      add (new const_attribute (DW_AT_encoding));
-      add (new flag_attribute (DW_AT_external));
-      add (new const_or_block_attribute (DW_AT_frame_base));
-      add (new ref_attribute (DW_AT_friend));
-      add (new const_attribute (DW_AT_identifier_case));
-      add (new const_attribute (DW_AT_macro_info));
-      add (new block_attribute (DW_AT_namelist_item));
-      add (new ref_attribute (DW_AT_priority));
-      add (new const_or_block_attribute (DW_AT_segment));
-      add (new ref_attribute (DW_AT_specification));
-      add (new const_or_block_attribute (DW_AT_static_link));
-      add (new ref_attribute (DW_AT_type));
-      add (new const_or_block_attribute (DW_AT_use_location));
-      add (new flag_attribute (DW_AT_variable_parameter));
-      add (new const_attribute (DW_AT_virtuality));
-      add (new ref_or_block_attribute (DW_AT_vtable_elem_location));
+      add (ref_attribute (DW_AT_sibling));
+      add (const_or_block_attribute (DW_AT_location));
+      add (string_attribute (DW_AT_name));
+      add (const_attribute (DW_AT_ordering));
+      add (const_attribute (DW_AT_byte_size));
+      add (const_attribute (DW_AT_bit_offset));
+      add (const_attribute (DW_AT_bit_size));
+      add (const_attribute (DW_AT_stmt_list));
+      add (addr_attribute (DW_AT_low_pc));
+      add (addr_attribute (DW_AT_high_pc));
+      add (const_attribute (DW_AT_language));
+      add (ref_attribute (DW_AT_discr));
+      add (const_attribute (DW_AT_discr_value));
+      add (const_attribute (DW_AT_visibility));
+      add (ref_attribute (DW_AT_import));
+      add (const_or_block_attribute (DW_AT_string_length));
+      add (ref_attribute (DW_AT_common_reference));
+      add (string_attribute (DW_AT_comp_dir));
+      add (attribute (DW_AT_const_value,
+                     dw_class_set (cl_string, cl_constant, cl_block)));
+      add (ref_attribute (DW_AT_containing_type));
+      add (ref_attribute (DW_AT_default_value));
+      add (const_attribute (DW_AT_inline));
+      add (flag_attribute (DW_AT_is_optional));
+      add (const_or_ref_attribute (DW_AT_lower_bound));
+      add (string_attribute (DW_AT_producer));
+      add (flag_attribute (DW_AT_prototyped));
+      add (const_or_block_attribute (DW_AT_return_addr));
+      add (const_attribute (DW_AT_start_scope));
+      add (const_attribute (DW_AT_bit_stride));
+      add (const_or_ref_attribute (DW_AT_upper_bound));
+      add (const_attribute (DW_AT_abstract_origin));
+      add (ref_attribute (DW_AT_accessibility));
+      add (const_attribute (DW_AT_address_class));
+      add (flag_attribute (DW_AT_artificial));
+      add (ref_attribute (DW_AT_base_types));
+      add (const_attribute (DW_AT_calling_convention));
+      add (const_or_ref_attribute (DW_AT_count));
+      add (ref_or_block_attribute (DW_AT_data_member_location));
+      add (const_attribute (DW_AT_decl_column));
+      add (const_attribute (DW_AT_decl_file));
+      add (const_attribute (DW_AT_decl_line));
+      add (flag_attribute (DW_AT_declaration));
+      add (block_attribute (DW_AT_discr_list));
+      add (const_attribute (DW_AT_encoding));
+      add (flag_attribute (DW_AT_external));
+      add (const_or_block_attribute (DW_AT_frame_base));
+      add (ref_attribute (DW_AT_friend));
+      add (const_attribute (DW_AT_identifier_case));
+      add (const_attribute (DW_AT_macro_info));
+      add (block_attribute (DW_AT_namelist_item));
+      add (ref_attribute (DW_AT_priority));
+      add (const_or_block_attribute (DW_AT_segment));
+      add (ref_attribute (DW_AT_specification));
+      add (const_or_block_attribute (DW_AT_static_link));
+      add (ref_attribute (DW_AT_type));
+      add (const_or_block_attribute (DW_AT_use_location));
+      add (flag_attribute (DW_AT_variable_parameter));
+      add (const_attribute (DW_AT_virtuality));
+      add (ref_or_block_attribute (DW_AT_vtable_elem_location));
     }
   };
 
@@ -103,30 +102,30 @@ namespace
   {
     dwarf_2_forms ()
     {
-      add (new block_form (DW_FORM_block, fw_uleb));
-      add (new block_form (DW_FORM_block1, fw_1));
-      add (new block_form (DW_FORM_block2, fw_2));
-      add (new block_form (DW_FORM_block4, fw_4));
+      add (block_form (DW_FORM_block, fw_uleb));
+      add (block_form (DW_FORM_block1, fw_1));
+      add (block_form (DW_FORM_block2, fw_2));
+      add (block_form (DW_FORM_block4, fw_4));
 
-      add (new const_form (DW_FORM_data1, fw_1));
-      add (new const_form (DW_FORM_data2, fw_2));
-      add (new const_form (DW_FORM_data4, fw_4));
-      add (new const_form (DW_FORM_data8, fw_8));
-      add (new const_form (DW_FORM_sdata, fw_sleb));
-      add (new const_form (DW_FORM_udata, fw_uleb));
+      add (const_form (DW_FORM_data1, fw_1));
+      add (const_form (DW_FORM_data2, fw_2));
+      add (const_form (DW_FORM_data4, fw_4));
+      add (const_form (DW_FORM_data8, fw_8));
+      add (const_form (DW_FORM_sdata, fw_sleb));
+      add (const_form (DW_FORM_udata, fw_uleb));
 
-      add (new flag_form (DW_FORM_flag, fw_1));
+      add (flag_form (DW_FORM_flag, fw_1));
 
-      add (new ref_form (DW_FORM_ref1, fw_1));
-      add (new ref_form (DW_FORM_ref2, fw_2));
-      add (new ref_form (DW_FORM_ref4, fw_4));
-      add (new ref_form (DW_FORM_ref8, fw_8));
-      add (new ref_form (DW_FORM_ref_udata, fw_uleb));
+      add (ref_form (DW_FORM_ref1, fw_1));
+      add (ref_form (DW_FORM_ref2, fw_2));
+      add (ref_form (DW_FORM_ref4, fw_4));
+      add (ref_form (DW_FORM_ref8, fw_8));
+      add (ref_form (DW_FORM_ref_udata, fw_uleb));
 
-      add (new string_form (DW_FORM_string));
-      add (new offset_form (DW_FORM_strp, cl_string));
-      add (new address_form (DW_FORM_addr, cl_address));
-      add (new address_form (DW_FORM_ref_addr, cl_reference));
+      add (string_form (DW_FORM_string));
+      add (offset_form (DW_FORM_strp, cl_string));
+      add (address_form (DW_FORM_addr, cl_address));
+      add (address_form (DW_FORM_ref_addr, cl_reference));
     }
   };
 

diff --git a/dwarflint/dwarf_3.cc b/dwarflint/dwarf_3.cc
index caf77e16276626f60bdf275572d80b94912003e1..3afb3ca58a1909cda356e28a37ab935694d97529 100644 (file)
--- a/dwarflint/dwarf_3.cc
+++ b/dwarflint/dwarf_3.cc
@@ -39,57 +39,55 @@ namespace
   {
     dwarf_3_attributes ()
     {
-      add (new block_or_loc_attribute (DW_AT_location));
-      add (new block_const_ref_attribute (DW_AT_byte_size));
-      add (new block_const_ref_attribute (DW_AT_bit_offset));
-      add (new block_const_ref_attribute (DW_AT_bit_size));
-      add (new basic_attribute (DW_AT_stmt_list, cl_lineptr));
-      add (new block_or_loc_attribute (DW_AT_string_length));
-      add (new basic_attribute (DW_AT_const_value,
-                               dw_class_set (cl_block, cl_constant,
-                                             cl_string)));
-      add (new block_const_ref_attribute (DW_AT_lower_bound));
-      add (new block_or_loc_attribute (DW_AT_return_addr));
-      add (new const_attribute (DW_AT_bit_stride));
-      add (new block_const_ref_attribute (DW_AT_upper_bound));
-      add (new block_const_ref_attribute (DW_AT_count));
-      add (new basic_attribute (DW_AT_data_member_location,
-                               dw_class_set (cl_block, cl_constant,
-                                             cl_loclistptr)));
-      add (new block_or_loc_attribute (DW_AT_frame_base));
-      add (new basic_attribute (DW_AT_macro_info, cl_macptr));
-      add (new block_or_loc_attribute (DW_AT_segment));
-      add (new block_or_loc_attribute (DW_AT_static_link));
-      add (new block_or_loc_attribute (DW_AT_use_location));
-      add (new block_or_loc_attribute (DW_AT_vtable_elem_location));
-      add (new block_const_ref_attribute (DW_AT_associated));
-      add (new block_attribute (DW_AT_data_location));
-      add (new block_const_ref_attribute (DW_AT_byte_stride));
-      add (new addr_attribute (DW_AT_entry_pc));
-      add (new flag_attribute (DW_AT_use_UTF8));
-      add (new ref_attribute (DW_AT_extension));
-      add (new basic_attribute (DW_AT_ranges, cl_rangelistptr));
-      add (new basic_attribute (DW_AT_trampoline,
-                               dw_class_set (cl_address, cl_flag,
-                                             cl_reference, cl_string)));
-      add (new const_attribute (DW_AT_call_column));
-      add (new const_attribute (DW_AT_call_file));
-      add (new const_attribute (DW_AT_call_line));
-      add (new string_attribute (DW_AT_description));
-      add (new const_attribute (DW_AT_binary_scale));
-      add (new const_attribute (DW_AT_decimal_scale));
-      add (new ref_attribute (DW_AT_small));
-      add (new const_attribute (DW_AT_decimal_sign));
-      add (new const_attribute (DW_AT_digit_count));
-      add (new string_attribute (DW_AT_picture_string));
-      add (new flag_attribute (DW_AT_mutable));
-      add (new flag_attribute (DW_AT_threads_scaled));
-      add (new flag_attribute (DW_AT_explicit));
-      add (new ref_attribute (DW_AT_object_pointer));
-      add (new const_attribute (DW_AT_endianity));
-      add (new flag_attribute (DW_AT_elemental));
-      add (new flag_attribute (DW_AT_pure));
-      add (new flag_attribute (DW_AT_recursive));
+      add (block_or_loc_attribute (DW_AT_location));
+      add (block_const_ref_attribute (DW_AT_byte_size));
+      add (block_const_ref_attribute (DW_AT_bit_offset));
+      add (block_const_ref_attribute (DW_AT_bit_size));
+      add (attribute (DW_AT_stmt_list, cl_lineptr));
+      add (block_or_loc_attribute (DW_AT_string_length));
+      add (attribute (DW_AT_const_value,
+                     dw_class_set (cl_block, cl_constant, cl_string)));
+      add (block_const_ref_attribute (DW_AT_lower_bound));
+      add (block_or_loc_attribute (DW_AT_return_addr));
+      add (const_attribute (DW_AT_bit_stride));
+      add (block_const_ref_attribute (DW_AT_upper_bound));
+      add (block_const_ref_attribute (DW_AT_count));
+      add (attribute (DW_AT_data_member_location,
+                     dw_class_set (cl_block, cl_constant, cl_loclistptr)));
+      add (block_or_loc_attribute (DW_AT_frame_base));
+      add (attribute (DW_AT_macro_info, cl_macptr));
+      add (block_or_loc_attribute (DW_AT_segment));
+      add (block_or_loc_attribute (DW_AT_static_link));
+      add (block_or_loc_attribute (DW_AT_use_location));
+      add (block_or_loc_attribute (DW_AT_vtable_elem_location));
+      add (block_const_ref_attribute (DW_AT_associated));
+      add (block_attribute (DW_AT_data_location));
+      add (block_const_ref_attribute (DW_AT_byte_stride));
+      add (addr_attribute (DW_AT_entry_pc));
+      add (flag_attribute (DW_AT_use_UTF8));
+      add (ref_attribute (DW_AT_extension));
+      add (attribute (DW_AT_ranges, cl_rangelistptr));
+      add (attribute (DW_AT_trampoline,
+                     dw_class_set (cl_address, cl_flag,
+                                   cl_reference, cl_string)));
+      add (const_attribute (DW_AT_call_column));
+      add (const_attribute (DW_AT_call_file));
+      add (const_attribute (DW_AT_call_line));
+      add (string_attribute (DW_AT_description));
+      add (const_attribute (DW_AT_binary_scale));
+      add (const_attribute (DW_AT_decimal_scale));
+      add (ref_attribute (DW_AT_small));
+      add (const_attribute (DW_AT_decimal_sign));
+      add (const_attribute (DW_AT_digit_count));
+      add (string_attribute (DW_AT_picture_string));
+      add (flag_attribute (DW_AT_mutable));
+      add (flag_attribute (DW_AT_threads_scaled));
+      add (flag_attribute (DW_AT_explicit));
+      add (ref_attribute (DW_AT_object_pointer));
+      add (const_attribute (DW_AT_endianity));
+      add (flag_attribute (DW_AT_elemental));
+      add (flag_attribute (DW_AT_pure));
+      add (flag_attribute (DW_AT_recursive));
     }
   };
 
@@ -102,9 +100,9 @@ namespace
   {
     dwarf_3_forms ()
     {
-      add (new dw3_data_form (DW_FORM_data4, fw_4));
-      add (new dw3_data_form (DW_FORM_data8, fw_8));
-      add (new offset_form (DW_FORM_ref_addr, cl_reference));
+      add (dw3_data_form (DW_FORM_data4, fw_4));
+      add (dw3_data_form (DW_FORM_data8, fw_8));
+      add (offset_form (DW_FORM_ref_addr, cl_reference));
     }
   };
 

diff --git a/dwarflint/dwarf_4.cc b/dwarflint/dwarf_4.cc
index 1733582eaa986e8da06cf03d34542c5cabf0a132..9b2f53d9e675bf67b901983de01dddd166708231 100644 (file)
--- a/dwarflint/dwarf_4.cc
+++ b/dwarflint/dwarf_4.cc
@@ -39,37 +39,35 @@ namespace
   {
     dwarf_4_attributes ()
     {
-      add (new exprloc_loclist_attribute (DW_AT_location));
-      add (new const_exprloc_ref_attribute (DW_AT_bit_offset));
-      add (new const_exprloc_ref_attribute (DW_AT_bit_size));
-      add (new basic_attribute (DW_AT_high_pc,
-                               dw_class_set (cl_address, cl_constant)));
-      add (new exprloc_loclist_attribute (DW_AT_string_length));
-      add (new basic_attribute (DW_AT_const_value,
-                               dw_class_set (cl_block, cl_constant,
-                                             cl_string)));
-      add (new const_exprloc_ref_attribute (DW_AT_lower_bound));
-      add (new exprloc_loclist_attribute (DW_AT_return_addr));
-      add (new const_exprloc_ref_attribute (DW_AT_bit_stride));
-      add (new const_exprloc_ref_attribute (DW_AT_upper_bound));
-      add (new const_exprloc_ref_attribute (DW_AT_count));
-      add (new basic_attribute (DW_AT_data_member_location,
-                               dw_class_set (cl_constant, cl_exprloc,
-                                             cl_loclistptr)));
-      add (new exprloc_loclist_attribute (DW_AT_frame_base));
-      add (new ref_attribute (DW_AT_namelist_item));
-      add (new exprloc_loclist_attribute (DW_AT_segment));
-      add (new exprloc_loclist_attribute (DW_AT_static_link));
-      add (new exprloc_loclist_attribute (DW_AT_use_location));
-      add (new exprloc_loclist_attribute (DW_AT_vtable_elem_location));
-      add (new const_exprloc_ref_attribute (DW_AT_allocated));
-      add (new const_exprloc_ref_attribute (DW_AT_associated));
-      add (new basic_attribute (DW_AT_data_location, cl_exprloc));
-      add (new const_exprloc_ref_attribute (DW_AT_byte_stride));
-      add (new ref_attribute (DW_AT_signature));
-      add (new flag_attribute (DW_AT_main_subprogram));
-      add (new const_attribute (DW_AT_data_bit_offset));
-      add (new flag_attribute (DW_AT_const_expr));
+      add (exprloc_loclist_attribute (DW_AT_location));
+      add (const_exprloc_ref_attribute (DW_AT_bit_offset));
+      add (const_exprloc_ref_attribute (DW_AT_bit_size));
+      add (attribute (DW_AT_high_pc,
+                     dw_class_set (cl_address, cl_constant)));
+      add (exprloc_loclist_attribute (DW_AT_string_length));
+      add (attribute (DW_AT_const_value,
+                     dw_class_set (cl_block, cl_constant, cl_string)));
+      add (const_exprloc_ref_attribute (DW_AT_lower_bound));
+      add (exprloc_loclist_attribute (DW_AT_return_addr));
+      add (const_exprloc_ref_attribute (DW_AT_bit_stride));
+      add (const_exprloc_ref_attribute (DW_AT_upper_bound));
+      add (const_exprloc_ref_attribute (DW_AT_count));
+      add (attribute (DW_AT_data_member_location,
+                     dw_class_set (cl_constant, cl_exprloc, cl_loclistptr)));
+      add (exprloc_loclist_attribute (DW_AT_frame_base));
+      add (ref_attribute (DW_AT_namelist_item));
+      add (exprloc_loclist_attribute (DW_AT_segment));
+      add (exprloc_loclist_attribute (DW_AT_static_link));
+      add (exprloc_loclist_attribute (DW_AT_use_location));
+      add (exprloc_loclist_attribute (DW_AT_vtable_elem_location));
+      add (const_exprloc_ref_attribute (DW_AT_allocated));
+      add (const_exprloc_ref_attribute (DW_AT_associated));
+      add (attribute (DW_AT_data_location, cl_exprloc));
+      add (const_exprloc_ref_attribute (DW_AT_byte_stride));
+      add (ref_attribute (DW_AT_signature));
+      add (flag_attribute (DW_AT_main_subprogram));
+      add (const_attribute (DW_AT_data_bit_offset));
+      add (flag_attribute (DW_AT_const_expr));
     }
   };
 
@@ -86,15 +84,14 @@ namespace
   {
     dwarf_4_forms ()
     {
-      add (new const_form (DW_FORM_data4, fw_4));
-      add (new const_form (DW_FORM_data8, fw_8));
-      add (new offset_form
-          (DW_FORM_sec_offset,
-           dw_class_set (cl_lineptr, cl_loclistptr,
-                         cl_macptr, cl_rangelistptr)));
-      add (new exprloc_form (DW_FORM_exprloc));
-      add (new flag_form (DW_FORM_flag_present, fw_0));
-      add (new ref_form (DW_FORM_ref_sig8, fw_8));
+      add (const_form (DW_FORM_data4, fw_4));
+      add (const_form (DW_FORM_data8, fw_8));
+      add (offset_form (DW_FORM_sec_offset,
+                       dw_class_set (cl_lineptr, cl_loclistptr,
+                                     cl_macptr, cl_rangelistptr)));
+      add (exprloc_form (DW_FORM_exprloc));
+      add (flag_form (DW_FORM_flag_present, fw_0));
+      add (ref_form (DW_FORM_ref_sig8, fw_8));
     }
   };
 

diff --git a/dwarflint/dwarf_version-imp.cc b/dwarflint/dwarf_version-imp.cc
index bc03d88eb5d4ed52ec5f17483fd25d4a5a96841e..01d05df3b95cb37b40485cc418bba93fef906c01 100644 (file)
--- a/dwarflint/dwarf_version-imp.cc
+++ b/dwarflint/dwarf_version-imp.cc
@@ -24,13 +24,12 @@
    <http://www.openinventionnetwork.com>.  */
 
 #include "dwarf_version-imp.hh"
-#include "check_debug_info.hh"
 
 template <class T>
 void
-dwver_index_table<T>::add (T const *f)
+dwver_index_table<T>::add (T const &emt)
 {
-  _m_data[f->name ()] = f;
+  _m_data.insert (std::make_pair (emt.name (), emt));
 }
 
 template <class T>
@@ -39,7 +38,7 @@ dwver_index_table<T>::get (int f) const
 {
   typename _map_t::const_iterator it = _m_data.find (f);
   if (it != _m_data.end ())
-    return it->second;
+    return &it->second;
   else
     return NULL;
 }
@@ -47,83 +46,14 @@ dwver_index_table<T>::get (int f) const
 template class dwver_index_table<form>;
 template class dwver_index_table<attribute>;
 
-template<class T>
-dwver_basic<T>::dwver_basic (int a_name, dw_class_set a_classes)
-  : _m_name (a_name)
-  , _m_classes (a_classes)
-{}
-
-template<class T>
-dw_class_set const &
-dwver_basic<T>::classes () const
-{
-  return _m_classes;
-}
-
-template<class T>
-int
-dwver_basic<T>::name () const
-{
-  return _m_name;
-}
-
-template class dwver_basic<form>;
-template class dwver_basic<attribute>;
-
-full_form::full_form (int a_name, dw_class_set a_classes,
-                     form_width_t a_width, storage_class_t a_storclass)
-  : basic_form (a_name, a_classes)
-  , _m_width (a_width)
-  , _m_storclass (a_storclass)
-{}
-
-form_width_t
-full_form::width (__attribute__ ((unused)) struct cu const *cu) const
-{
-  return _m_width;
-}
-
-storage_class_t
-full_form::storage_class () const
-{
-  return _m_storclass;
-}
-
-
 offset_form::offset_form (int a_name, dw_class_set a_classes)
-  : basic_form (a_name, a_classes)
+  : form (a_name, a_classes, fw_offset, sc_value)
 {}
 
-form_width_t
-offset_form::width (cu const *cu) const
-{
-  return static_cast<form_width_t> (cu->head->offset_size);
-}
-
-storage_class_t
-offset_form::storage_class () const
-{
-  return sc_value;
-}
-
-
 address_form::address_form (int a_name, dw_class_set a_classes)
-  : basic_form (a_name, a_classes)
+  : form (a_name, a_classes, fw_address, sc_value)
 {}
 
-form_width_t
-address_form::width (cu const *cu) const
-{
-  return static_cast<form_width_t> (cu->head->address_size);
-}
-
-storage_class_t
-address_form::storage_class () const
-{
-  return sc_value;
-}
-
-
 string_form::string_form (int a_name)
   : preset_form<sc_string, cl_string> (a_name, fw_unknown)
 {}

diff --git a/dwarflint/dwarf_version-imp.hh b/dwarflint/dwarf_version-imp.hh
index 126850d7f41c936c9de87c8cb4f84655c2a70281..6f4fc8bd57f3c62633c9389e2f37fa23417d7e81 100644 (file)
--- a/dwarflint/dwarf_version-imp.hh
+++ b/dwarflint/dwarf_version-imp.hh
@@ -32,11 +32,11 @@
 template <class T>
 class dwver_index_table
 {
-  typedef std::map<int, T const *> _map_t;
+  typedef std::map<int, T> _map_t;
   _map_t _m_data;
 
 protected:
-  void add (T const *f);
+  void add (T const &f);
 
 public:
   T const *get (int f) const;
@@ -45,73 +45,35 @@ public:
 typedef dwver_index_table<form> form_table;
 typedef dwver_index_table<attribute> attribute_table;
 
-template<class T>
-class dwver_basic
-  : public T
-{
-  int _m_name;
-  dw_class_set _m_classes;
-
-public:
-  dwver_basic (int a_name, dw_class_set a_classes);
-
-  dw_class_set const &classes () const;
-  int name () const;
-};
-
-typedef dwver_basic<form> basic_form;
-typedef dwver_basic<attribute> basic_attribute;
-
-class full_form
-  : public basic_form
-{
-protected:
-  form_width_t _m_width;
-  storage_class_t _m_storclass;
-
-public:
-  full_form (int a_name, dw_class_set a_classes,
-            form_width_t a_width, storage_class_t a_storclass);
-
-  form_width_t width (cu const *cu = NULL) const;
-  storage_class_t storage_class () const;
-};
-
 template<storage_class_t StorClass, dw_class... Classes>
 struct preset_form
-  : public full_form
+  : public form
 {
   preset_form (int a_name, form_width_t a_width)
-    : full_form (a_name, dw_class_set (Classes...), a_width, StorClass)
+    : form (a_name, dw_class_set (Classes...), a_width, StorClass)
   {}
 };
 
 template<dw_class... Classes>
 struct preset_attribute
-  : public basic_attribute
+  : public attribute
 {
   preset_attribute (int a_name)
-    : basic_attribute (a_name, dw_class_set (Classes...))
+    : attribute (a_name, dw_class_set (Classes...))
   {}
 };
 
 \f
 struct offset_form
-  : public basic_form
+  : public form
 {
   offset_form (int a_name, dw_class_set a_classes);
-
-  form_width_t width (cu const *cu) const;
-  storage_class_t storage_class () const;
 };
 
 struct address_form
-  : public basic_form
+  : public form
 {
   address_form (int a_name, dw_class_set a_classes);
-
-  form_width_t width (cu const *cu) const;
-  storage_class_t storage_class () const;
 };
 
 struct string_form

diff --git a/dwarflint/dwarf_version.cc b/dwarflint/dwarf_version.cc
index dd61a35e573e15e9459d21828f0a42de3d77d36d..f62992f96870af6da14170c9bedc45dfbf49a42e 100644 (file)
--- a/dwarflint/dwarf_version.cc
+++ b/dwarflint/dwarf_version.cc
@@ -31,6 +31,7 @@
 #include "dwarf_2.hh"
 #include "dwarf_3.hh"
 #include "dwarf_4.hh"
+#include "check_debug_info.hh"
 
 #include "../libdw/dwarf.h"
 #include <map>
@@ -48,6 +49,39 @@ dw_class_set::dw_class_set (dw_class a, dw_class b, dw_class c,
 #undef ADD
 }
 
+form::form (int a_name, dw_class_set a_classes,
+           form_width_t a_width, storage_class_t a_storclass)
+  : _m_name (a_name)
+  , _m_classes (a_classes)
+  , _m_width (a_width)
+  , _m_storclass (a_storclass)
+{}
+
+form::form (int a_name, dw_class_set a_classes,
+      form_width_special_t a_width, storage_class_t a_storclass)
+  : _m_name (a_name)
+  , _m_classes (a_classes)
+  , _m_width (a_width)
+  , _m_storclass (a_storclass)
+{}
+
+form_width_t
+form::width (cu const *cu) const
+{
+  if (_m_width == fw_offset)
+    return static_cast<form_width_t> (cu->head->offset_size);
+  else if (_m_width == fw_address)
+    return static_cast<form_width_t> (cu->head->address_size);
+  else
+    return static_cast<form_width_t> (_m_width);
+}
+
+attribute::attribute (int a_name, dw_class_set a_classes)
+  : _m_name (a_name)
+  , _m_classes (a_classes)
+{}
+
+
 bool
 dwarf_version::form_allowed (int form) const
 {

diff --git a/dwarflint/dwarf_version.hh b/dwarflint/dwarf_version.hh
index f93e334a92bda96da96ac3414efd0af942d8242a..db3e3e06fb2b27e0c25902f30019275a1dda22d6 100644 (file)
--- a/dwarflint/dwarf_version.hh
+++ b/dwarflint/dwarf_version.hh
@@ -64,7 +64,15 @@ enum form_width_t
     fw_8 = 8,
     fw_sleb,
     fw_uleb,
-    fw_unknown
+    fw_unknown,
+  };
+
+/// Special forms for use in DWARF tables.  These never leak out to
+/// the user of dwarf_version.
+enum form_width_special_t
+  {
+    fw_offset = fw_unknown + 1,
+    fw_address,
   };
 
 enum storage_class_t
@@ -76,11 +84,30 @@ enum storage_class_t
 
 class form
 {
+  int const _m_name;
+  dw_class_set const _m_classes;
+  int const _m_width;
+  storage_class_t const _m_storclass;
+
 public:
-  virtual int name () const = 0;
+  form (int a_name, dw_class_set a_classes,
+       form_width_t a_width, storage_class_t a_storclass);
+
+  form (int a_name, dw_class_set a_classes,
+       form_width_special_t a_width, storage_class_t a_storclass);
+
+  int
+  name () const
+  {
+    return _m_name;
+  }
 
   /// Answer set of DWARF classes that this form can have.
-  virtual dw_class_set const &classes () const = 0;
+  dw_class_set const &
+  classes () const
+  {
+    return _m_classes;
+  }
 
   /// Return width of data stored with given form.  CU may be NULL if
   /// you are sure that the form size doesn't depend on bitness of
@@ -89,20 +116,40 @@ public:
   /// Forms for which width makes no sense (namely those in the
   /// storage class of sc_string) get fw_unknown.  Unknown forms get
   /// an assert.
-  virtual form_width_t width (cu const *cu = NULL) const = 0;
+  ///
+  /// Return value is never fw_offset or fw_address.  These get
+  /// resolved to fw_4 or fw_8 depending on corresponding value in
+  /// CU->head.
+  form_width_t width (cu const *cu = NULL) const;
 
   /// Return storage class of given form.  Closely related to width.
-  virtual storage_class_t storage_class () const = 0;
-
-  virtual ~form () {}
+  storage_class_t
+  storage_class () const
+  {
+    return _m_storclass;
+  }
 };
 
 class attribute
 {
+  int const _m_name;
+  dw_class_set const _m_classes;
+
 public:
-  virtual int name () const = 0;
-  virtual dw_class_set const &classes () const = 0;
-  virtual ~attribute () {}
+  attribute (int a_name, dw_class_set a_classes);
+
+  int
+  name () const
+  {
+    return _m_name;
+  }
+
+  /// Answer set of DWARF classes that this form can have.
+  dw_class_set const &
+  classes () const
+  {
+    return _m_classes;
+  }
 };
 
 class dwarf_version