atosl 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bcf2f819cf10ef934ef1c7c741af28d4eaafd907
+  data.tar.gz: 35db780cd14acb2383c4973fe35d5ea5a96b57be
+SHA512:
+  metadata.gz: ee47e199ed2aa3fb9908730f31da057cd1876194089d3a91c003906c9fb1536c84526fb599303b04cfc15c5c0bffa8818f50bb48a5ef93e77fe2fdd48873f5ce
+  data.tar.gz: 2c722675ecf90dab8483006e802dfe0648095f01c51775cf0d4262ead079d65ad3bff8ee6577af855cbbccd47275cbe39009e75c26129b218e28ff183b5dbaa3

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+lib/atosl/atosl.bundle
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+ext/atosl/atosl.bundle
+.DS_Store
+*/.DS_Store
+ext/atosl/mkmf.log
+ext/atosl/Makefile

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in atosl.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Reno Qiu
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,33 @@
+# Atosl
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'atosl'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install atosl
+
+## Usage
+
+    Usage: atosl --arch architecture -o executable -a [address,address,...]
+
+## Reference
+
+    [Original](https://github.com/renoqiu/atosl "atosl").
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require "rake/extensiontask"
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test
+
+Rake::ExtensionTask.new "atosl" do |ext|
+    ext.lib_dir = "lib/atosl"
+end

data/atosl.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'atosl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "atosl"
+  spec.version       = Atosl::VERSION
+  spec.authors       = ["Reno Qiu"]
+  spec.email         = ["dechao.qiu@gmail.com"]
+  spec.summary       = %q{atos for Linux.}
+  spec.description   = %q{atosl is used for converting binary addresses within a macho file to symbols.}
+  spec.homepage      = "https://github.com/renoqiu/atosl"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.extensions << "ext/atosl/extconf.rb"
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.4"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+end

data/bin/atosl

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'atosl'
+
+options = {}
+
+opts = OptionParser.new do |opts|
+  opts.banner = "atosl: atos on linux for converting binary addresses into symbols."
+  opts.define_head "Usage: atosl --arch architecture -o executable -a [address,address,...]"
+  opts.separator ""
+  opts.separator "Examples:"
+  opts.separator "  atosl --arch ARMV7S -o ~/TEST -a 0X00001100 0X00001200"
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on("--arch [architecture]") do |v|
+    @arch = v.to_s
+    options[:arch] = v.to_s
+  end
+
+  opts.on("-o macho_path", "Specifies target macho file path from command-line.") do |v|
+    @macho_path = v
+    options[:macho_path] = v
+  end
+
+  opts.on('-a address1,address2', '--address address1,address2', Array, 'List of addresses') do |value|
+    options[:addresses] = value
+  end
+
+  opts.on_tail("-?", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("-v", "--version", "Show version") do
+    puts Atosl::VERSION
+    exit
+  end
+end
+opts.parse!
+
+if options[:arch].nil? or options[:macho_path].nil? or options[:addresses].nil?
+  puts opts
+  raise OptionParser::MissingArgument
+end
+
+Atosl.convert(options[:arch], options[:macho_path], options[:addresses])

data/ext/atosl/atosl.c

@@ -0,0 +1,153 @@
+/*
+ * =====================================================================================
+ *
+ *       Filename:  atosl.c
+ *
+ *    Description:  Main Function
+ *
+ *        Version:  1.0
+ *        Created:  02/17/2013 19:00:22
+ *       Revision:  none
+ *       Compiler:  gcc
+ *
+ *         Author:  Reno Qiu
+ *   Organization:
+ *
+ * =====================================================================================
+ */
+#include <stdio.h>
+#include "macho.h"
+#include <ruby.h>
+
+extern char *project_name;
+
+static int lookup_by_address(struct thin_macho *thin_macho, CORE_ADDR integer_address){
+    int result = -1;
+    if(thin_macho->dwarf2_per_objfile != NULL){
+        result = lookup_by_address_in_dwarf(thin_macho, integer_address);
+    }
+    if(result == -1){
+        result = lookup_by_address_in_symtable(thin_macho, integer_address);
+    }
+    return result;
+}
+
+static void numeric_to_symbols(struct thin_macho *thin_macho, const char **addresses, int numofaddresses){
+    int i = 0;
+    const char *address = NULL;
+    CORE_ADDR integer_address = 0;
+
+    for (i = 0; i < numofaddresses; i++){
+        address = addresses[i];
+        if(address[0] == '0' && (address[1] == 'x' || address[1] == 'X')){
+            //address start with 0x
+            integer_address = strtoll(address, NULL, 0);
+        }else{
+            integer_address= strtoll(address, NULL, 16);
+        }
+
+        if (lookup_by_address(thin_macho, integer_address) != 0){
+            printf("%s\n", addresses[i]);
+        }
+    }
+}
+
+static void set_project_name(const char* full_filename){
+    char *filename = strrchr(full_filename, '/');
+    if(filename == NULL){
+        filename = (char *)full_filename;
+    }else{
+        filename = filename + 1;
+    }
+    project_name = filename;
+}
+
+
+int symbolicate(const char* arch, const char *executable, char *addresses[], int numofaddresses){
+    debug("in symbolicate arch: %s executable: %s\n", arch, executable);
+    set_project_name(executable);
+    debug("about to parse file.");
+    struct target_file *tf = parse_file(executable);
+    if (tf == NULL){
+        debug("parse target file error.");
+        return -1;
+    }
+    debug("parse file finished.");
+
+    struct thin_macho *thin_macho = NULL;
+    //TODO performance
+    int i = select_thin_macho_by_arch(tf, arch);
+    if(i == -1){
+        printf("atosl: Can not find macho for architecture: %s.\n", arch);
+        return -1;
+    }
+    thin_macho = tf->thin_machos[i];
+    //#ifdef DEBUG
+    //    print_all_dwarf2_per_objfile(thin_macho->dwarf2_per_objfile);
+    //#endif
+
+    debug("thin_macho->dwarf2_per_objfile: %p.", thin_macho->dwarf2_per_objfile);
+    if(thin_macho->dwarf2_per_objfile != NULL){
+        debug("about to parse dwarf2 objfile.");
+        parse_dwarf2_per_objfile(thin_macho->dwarf2_per_objfile);
+        debug("parse dwarf2 objfile finished.");
+    }
+
+    #ifdef DEBUG
+        print_thin_macho_aranges(thin_macho);
+    #endif
+
+    debug("about to invoke numeric_to_symbols.");
+    numeric_to_symbols(thin_macho, (const char **)addresses, numofaddresses);
+    free_target_file(tf);
+    return 0;
+}
+
+// Initial setup function, takes no arguments and returns nothing. Some API
+// notes:
+//
+// * rb_define_module() creates and returns a top-level module by name
+//
+// * rb_define_module_under() takes a module and a name, and creates a new
+//   module within the given one
+//
+// * rb_define_singleton_method() take a module, the method name, a reference to
+//   a C function, and the method's arity, and exposes the C function as a
+//   single method on the given module
+VALUE Atosl;
+
+VALUE symbolicate_wrapper(VALUE self, VALUE arch, VALUE executable, VALUE addresses){
+    int numofaddresses = RARRAY_LEN(addresses);
+    char *arch_str = RSTRING_PTR(StringValue(arch));
+    char *executable_str = RSTRING_PTR(StringValue(executable));
+    char **addresses_array = malloc(numofaddresses * sizeof(char *));
+    for (int i = 0; i < numofaddresses; i++){
+        VALUE ret = rb_ary_entry(addresses, i);
+        addresses_array[i] = RSTRING_PTR(StringValue(ret));
+    }
+    int result = symbolicate(arch_str, executable_str, addresses_array, numofaddresses);
+    free(addresses_array);
+    return INT2NUM(result);
+}
+void Init_atosl(){
+    Atosl = rb_define_module("Atosl");
+    rb_define_singleton_method(Atosl, "symbolicate", symbolicate_wrapper, 3);
+}
+
+int main(int argc, char *argv[]){
+    if (argc < 6){
+        printf("usage:  atosl -arch architecture -o executable [address ...]\n");
+        exit(-1);
+    }
+    assert(strcmp(argv[1], "-arch") == 0);
+    char *arch = argv[2];
+    assert(strcmp(argv[3], "-o") == 0);
+
+    char *executable = argv[4];
+
+    int numofaddresses = argc - 5;
+    char **addresses = argv + 5;
+    int result = symbolicate(arch, executable, addresses, numofaddresses);
+    return result;
+}
+

data/ext/atosl/atosl.h

@@ -0,0 +1,4 @@
+#ifndef ATOSL_H
+#define ATOSL_H
+int symbolicate(const char* arch, const char *executable, char *addresses[], int numofaddresses);
+#endif

data/ext/atosl/converter.c

@@ -0,0 +1,411 @@
+/*
+ * =====================================================================================
+ *
+ *       Filename:  converter.c
+ *
+ *    Description:  Convert code to string or enum type
+ *
+ *        Version:  1.0
+ *        Created:  21/02/13 08:54:55
+ *       Revision:  none
+ *       Compiler:  gcc
+ *
+ *         Author:  Reno Qiu
+ *   Organization:
+ *
+ * =====================================================================================
+ */
+
+#include "converter.h"
+/* Convert a DWARF attribute code into its string name.  */
+
+const char* dwarf_attr_name (unsigned int attr)
+{
+    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_stride_size:
+            return "DW_AT_stride_size";
+        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_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_stride:
+            return "DW_AT_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";
+            //#ifdef MIPS
+            //    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";
+            //    case DW_AT_MIPS_loop_unroll_factor:
+            //      return "DW_AT_MIPS_loop_unroll_factor";
+            //    case DW_AT_MIPS_software_pipeline_depth:
+            //      return "DW_AT_MIPS_software_pipeline_depth";
+            //#endif
+        case DW_AT_MIPS_linkage_name:
+            return "DW_AT_MIPS_linkage_name";
+
+        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";
+            //    /* APPLE LOCAL begin dwarf repository  */
+            //    case DW_AT_APPLE_repository_file:
+            //      return "DW_AT_APPLE_repository_file";
+            //    case DW_AT_APPLE_repository_type:
+            //      return "DW_AT_APPLE_repository_type";
+            //    case DW_AT_APPLE_repository_name:
+            //      return "DW_AT_APPLE_repository_name";
+            //    case DW_AT_APPLE_repository_specification:
+            //      return "DW_AT_APPLE_repository_specification";
+            //    case DW_AT_APPLE_repository_import:
+            //      return "DW_AT_APPLE_repository_import";
+            //    case DW_AT_APPLE_repository_abstract_origin:
+            //      return "DW_AT_APPLE_repository_abstract_origin";
+            /* APPLE LOCAL end dwarf repository  */
+        default:
+            return "DW_AT_<unknown>";
+    }
+}
+
+
+
+/* Convert a DWARF value form code into its string name.  */
+
+const char * dwarf_form_name (unsigned 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_APPLE_db_str:
+            //  return "DW_FORM_APPLE_db_str";
+        default:
+            return "DW_FORM_<unknown>";
+    }
+}
+
+/* Convert a DIE tag into its string name.  */
+
+const char * dwarf_tag_name (unsigned 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_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";
+        default:
+            return "DW_TAG_<unknown>";
+    }
+}
+