/*******************************************************************************
 * Copyright (c) 2007, 2011 Wind River Systems, Inc. and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Eclipse Distribution License v1.0 which accompany this distribution.
 * The Eclipse Public License is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 * You may elect to redistribute this code under either of these licenses.
 *
 * Contributors:
 *     Wind River Systems - initial API and implementation
 *******************************************************************************/

/*
 * Symbols service - ELF version.
 */

#include <config.h>

#if SERVICE_Symbols && !ENABLE_SymbolsProxy && ENABLE_ELF

#if defined(_WRS_KERNEL)
#  include <symLib.h>
#  include <sysSymTbl.h>
#endif

#include <errno.h>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <framework/errors.h>
#include <framework/myalloc.h>
#include <framework/events.h>
#include <framework/exceptions.h>
#include <services/tcf_elf.h>
#include <services/dwarf.h>
#include <services/dwarfcache.h>
#include <services/dwarfexpr.h>
#include <services/dwarfframe.h>
#include <services/stacktrace.h>
#include <services/symbols.h>
#if ENABLE_RCBP_TEST
#  include <main/test.h>
#endif

struct Symbol {
    unsigned magic;
    ObjectInfo * obj;
    ObjectInfo * var; /* 'this' object if the symbol represents implicit 'this' reference */
    ELF_Section * tbl;
    int has_size;
    int has_address;
    ContextAddress size;
    ContextAddress address;
    int sym_class;
    Context * ctx;
    int frame;
    unsigned index;
    unsigned dimension;
    unsigned cardinal;
    ContextAddress length;
    Symbol * base;
};

#define is_cardinal_type_pseudo_symbol(s) (s->sym_class == SYM_CLASS_TYPE && s->obj == NULL && s->base == NULL)

#include <services/symbols_alloc.h>

static Context * sym_ctx;
static int sym_frame;
static ContextAddress sym_ip;

static int get_sym_context(Context * ctx, int frame, ContextAddress addr) {
    if (frame == STACK_NO_FRAME) {
        ctx = context_get_group(ctx, CONTEXT_GROUP_PROCESS);
        sym_ip = addr;
    }
    else if (frame == STACK_TOP_FRAME) {
        if (!ctx->stopped) {
            errno = ERR_IS_RUNNING;
            return -1;
        }
        if (ctx->exited) {
            errno = ERR_ALREADY_EXITED;
            return -1;
        }
        sym_ip = get_regs_PC(ctx);
    }
    else {
        U8_T ip = 0;
        StackFrame * info = NULL;
        if (get_frame_info(ctx, frame, &info) < 0) return -1;
        if (read_reg_value(info, get_PC_definition(ctx), &ip) < 0) return -1;
        sym_ip = (ContextAddress)ip;
    }
    sym_ctx = ctx;
    sym_frame = frame;
    return 0;
}

/* Map ELF symbol table entry value to run-time address in given context address space */
static int syminfo2address(Context * ctx, ELF_SymbolInfo * info, ContextAddress * address) {
    switch (info->type) {
    case STT_OBJECT:
    case STT_FUNC:
        {
            U8_T value = info->value;
            ELF_File * file = info->sym_section->file;
            ELF_Section * sec = NULL;
            if (info->section_index == SHN_UNDEF) {
                errno = ERR_INV_ADDRESS;
                return -1;
            }
            if (info->section_index == SHN_ABS) {
                *address = (ContextAddress)value;
                return 0;
            }
            if (info->section_index == SHN_COMMON) {
                errno = ERR_INV_ADDRESS;
                return -1;
            }
            if (file->type == ET_REL && info->section != NULL) {
                sec = info->section;
                value += sec->addr;
            }
            *address = elf_map_to_run_time_address(ctx, file, sec, (ContextAddress)value);
            if (*address == 0 && file->type == ET_EXEC) *address = (ContextAddress)value;
            return 0;
        }
    }
    errno = ERR_INV_ADDRESS;
    return -1;
}

static int is_frame_based_object(Symbol * sym) {
    int res = 0;
    ContextAddress addr = 0;
    ContextAddress size = 0;
    Context * org_ctx = sym_ctx;
    int org_frame = sym_frame;
    ContextAddress org_ip = sym_ip;

    if (sym->sym_class == SYM_CLASS_REFERENCE) {
        if (get_symbol_address(sym, &addr) < 0) {
            res = 1;
        }
        else {
            sym->has_address = 1;
            sym->address = addr;
        }
    }

    if (!res) {
        if (get_symbol_size(sym, &size) < 0) {
            res = 1;
        }
        else {
            sym->has_size = 1;
            sym->size = size;
        }
    }

    sym_ctx = org_ctx;
    sym_frame = org_frame;
    sym_ip = org_ip;
    return res;
}

static void object2symbol(ObjectInfo * obj, Symbol ** res) {
    Symbol * sym = alloc_symbol();
    sym->obj = obj;
    switch (obj->mTag) {
    case TAG_global_subroutine:
    case TAG_subroutine:
    case TAG_subprogram:
    case TAG_entry_point:
        sym->sym_class = SYM_CLASS_FUNCTION;
        break;
    case TAG_array_type:
    case TAG_class_type:
    case TAG_enumeration_type:
    case TAG_pointer_type:
    case TAG_reference_type:
    case TAG_mod_pointer:
    case TAG_mod_reference:
    case TAG_string_type:
    case TAG_structure_type:
    case TAG_subroutine_type:
    case TAG_union_type:
    case TAG_ptr_to_member_type:
    case TAG_set_type:
    case TAG_subrange_type:
    case TAG_base_type:
    case TAG_fund_type:
    case TAG_file_type:
    case TAG_packed_type:
    case TAG_thrown_type:
    case TAG_const_type:
    case TAG_volatile_type:
    case TAG_restrict_type:
    case TAG_interface_type:
    case TAG_unspecified_type:
    case TAG_mutable_type:
    case TAG_shared_type:
    case TAG_typedef:
        sym->sym_class = SYM_CLASS_TYPE;
        break;
    case TAG_global_variable:
    case TAG_inheritance:
    case TAG_member:
    case TAG_formal_parameter:
    case TAG_unspecified_parameters:
    case TAG_local_variable:
    case TAG_variable:
        sym->sym_class = SYM_CLASS_REFERENCE;
        break;
    case TAG_constant:
    case TAG_enumerator:
        sym->sym_class = SYM_CLASS_VALUE;
        break;
    }
    sym->frame = STACK_NO_FRAME;
    sym->ctx = context_get_group(sym_ctx, CONTEXT_GROUP_PROCESS);
    if (sym_frame != STACK_NO_FRAME && is_frame_based_object(sym)) {
        sym->frame = sym_frame;
        sym->ctx = sym_ctx;
    }
    *res = sym;
}

static ObjectInfo * get_object_type(ObjectInfo * obj) {
    if (obj != NULL) {
        switch (obj->mTag) {
        case TAG_global_subroutine:
        case TAG_subroutine:
        case TAG_subprogram:
        case TAG_entry_point:
        case TAG_enumerator:
        case TAG_formal_parameter:
        case TAG_unspecified_parameters:
        case TAG_global_variable:
        case TAG_local_variable:
        case TAG_variable:
        case TAG_inheritance:
        case TAG_member:
        case TAG_constant:
            obj = obj->mType;
            break;
        }
    }
    return obj;
}

static int is_modified_type(ObjectInfo * obj) {
    if (obj != NULL && obj->mType != NULL) {
        switch (obj->mTag) {
        case TAG_subrange_type:
        case TAG_packed_type:
        case TAG_const_type:
        case TAG_volatile_type:
        case TAG_restrict_type:
        case TAG_shared_type:
        case TAG_typedef:
            return 1;
        }
    }
    return 0;
}

static ObjectInfo * get_original_type(ObjectInfo * obj) {
    obj = get_object_type(obj);
    while (is_modified_type(obj)) {
        obj = obj->mType;
    }
    return obj;
}

static int get_num_prop(ObjectInfo * obj, int at, U8_T * res) {
    Trap trap;
    PropertyValue v;

    if (!set_trap(&trap)) return 0;
    /* XXX : fle : check if cast is not an error */
    read_and_evaluate_dwarf_object_property(sym_ctx, sym_frame, 0, obj, (U2_T) at, &v);
    *res = get_numeric_property_value(&v);
    clear_trap(&trap);
    return 1;
}

/* Check run-time 'addr' belongs to an object address range(s) */
static int check_in_range(ObjectInfo * obj, ContextAddress rt_offs, ContextAddress addr) {
    Trap trap;

    if (obj->u.mAddr.mHighPC > obj->u.mAddr.mLowPC) {
        ContextAddress lt_addr = addr - rt_offs;
        return lt_addr >= obj->u.mAddr.mLowPC && lt_addr < obj->u.mAddr.mHighPC;
    }

    if (set_trap(&trap)) {
        CompUnit * unit = obj->mCompUnit;
        DWARFCache * cache = get_dwarf_cache(unit->mFile);
        ELF_Section * debug_ranges = cache->mDebugRanges;
        if (debug_ranges != NULL) {
            ContextAddress lt_addr = addr - rt_offs;
            ContextAddress base = unit->mLowPC;
            PropertyValue v;
            U8_T offs = 0;
            int res = 0;

            read_and_evaluate_dwarf_object_property(sym_ctx, sym_frame, 0, obj, AT_ranges, &v);
            offs = get_numeric_property_value(&v);
            dio_EnterSection(&unit->mDesc, debug_ranges, offs);
            for (;;) {
                ELF_Section * sec = NULL;
                U8_T x = dio_ReadAddress(&sec);
                U8_T y = dio_ReadAddress(&sec);
                if (x == 0 && y == 0) break;
                if (x == ((U8_T)1 << unit->mDesc.mAddressSize * 8) - 1) {
                    base = (ContextAddress)y;
                }
                else {
                    x = base + x;
                    y = base + y;
                    if (x <= lt_addr && lt_addr < y) {
                        res = 1;
                        break;
                    }
                }
            }
            dio_ExitSection();
            clear_trap(&trap);
            return res;
        }
        clear_trap(&trap);
    }
    return 0;
}

static int find_in_object_tree(ObjectInfo * list, ContextAddress rt_offs, ContextAddress ip, const char * name, Symbol ** sym) {
    Symbol * sym_imp = NULL;  /* Imported from a namespace */
    Symbol * sym_enu = NULL;  /* Enumeration constant */
    Symbol * sym_cur = NULL;  /* Found in current scope */
    Symbol * sym_base = NULL; /* Found in base class (inherited) */
    Symbol * sym_this = NULL; /* Found in 'this' reference */
    ObjectInfo * obj = list;
    while (obj != NULL) {
        if (obj->mName != NULL) {
            U8_T v = 0;
            if (strcmp(obj->mName, name) == 0) {
                object2symbol(obj, &sym_cur);
            }
            if (sym_frame != STACK_NO_FRAME && strcmp(obj->mName, "this") == 0 && get_num_prop(obj, AT_artificial, &v) && v != 0) {
                ObjectInfo * type = get_original_type(obj);
                if ((type->mTag == TAG_pointer_type || type->mTag == TAG_mod_pointer) && type->mType != NULL) {
                    type = get_original_type(type->mType);
                    find_in_object_tree(type->mChildren, 0, 0, name, &sym_this);
                    if (sym_this != NULL) {
                        sym_this->ctx = sym_ctx;
                        sym_this->frame = sym_frame;
                        sym_this->var = obj;
                    }
                }
            }
        }
        switch (obj->mTag) {
        case TAG_enumeration_type:
            find_in_object_tree(obj->mChildren, 0, 0, name, &sym_enu);
            break;
        case TAG_global_subroutine:
        case TAG_subroutine:
        case TAG_subprogram:
        case TAG_entry_point:
        case TAG_lexical_block:
        case TAG_inlined_subroutine:
            if (ip != 0 && check_in_range(obj, rt_offs, ip)) {
                if (find_in_object_tree(obj->mChildren, rt_offs, ip, name, sym)) return 1;
            }
            break;
        case TAG_inheritance:
            find_in_object_tree(obj->mType->mChildren, 0, 0, name, &sym_base);
            break;
        case TAG_imported_module:
            {
                PropertyValue p;
                ObjectInfo * module;
                read_and_evaluate_dwarf_object_property(sym_ctx, sym_frame, 0, obj, AT_import, &p);
                module = find_object(get_dwarf_cache(obj->mCompUnit->mFile), p.mValue);
                if (module != NULL) find_in_object_tree(module->mChildren, 0, 0, name, &sym_imp);
            }
            break;
        }
        obj = obj->mSibling;
    }
    if (*sym == NULL) *sym = sym_cur;
    if (*sym == NULL) *sym = sym_base;
    if (*sym == NULL) *sym = sym_this;
    if (*sym == NULL) *sym = sym_enu;
    if (*sym == NULL) *sym = sym_imp;
    return *sym != NULL;
}

static int find_in_dwarf(const char * name, Symbol ** sym) {
    ContextAddress rt_addr = 0;
    UnitAddressRange * range = elf_find_unit(sym_ctx, sym_ip, sym_ip, &rt_addr);
    *sym = NULL;
    if (range != NULL) {
        CompUnit * unit = range->mUnit;
        if (find_in_object_tree(unit->mObject->mChildren, rt_addr - range->mAddr, sym_ip, name, sym)) return 1;
        if (unit->mBaseTypes != NULL) {
            if (find_in_object_tree(unit->mBaseTypes->mObject->mChildren, 0, 0, name, sym)) return 1;
        }
    }
    return 0;
}

static int find_by_name_in_pub_names(DWARFCache * cache, PubNamesTable * tbl, char * name, Symbol ** sym) {
    unsigned n = tbl->mHash[calc_symbol_name_hash(name)];
    while (n != 0) {
        U8_T id = tbl->mNext[n].mID;
        ObjectInfo * obj = find_object(cache, id);
        if (obj == NULL || obj->mName == NULL) str_exception(ERR_INV_DWARF, "Invalid .debug_pubnames section");
        if (strcmp(obj->mName, name) == 0) {
            object2symbol(obj, sym);
            return 1;
        }
        n = tbl->mNext[n].mNext;
    }
    return 0;
}

static void create_symbol_names_hash(ELF_Section * tbl) {
    unsigned i;
    unsigned sym_size = tbl->file->elf64 ? sizeof(Elf64_Sym) : sizeof(Elf32_Sym);
    unsigned sym_cnt = (unsigned)(tbl->size / sym_size);
    tbl->sym_names_hash = (unsigned *)loc_alloc_zero(SYM_HASH_SIZE * sizeof(unsigned));
    tbl->sym_names_next = (unsigned *)loc_alloc_zero(sym_cnt * sizeof(unsigned));
    for (i = 0; i < sym_cnt; i++) {
        ELF_SymbolInfo sym;
        unpack_elf_symbol_info(tbl, i, &sym);
        if (sym.bind == STB_GLOBAL && sym.name != NULL && sym.section_index != SHN_UNDEF) {
            unsigned h = calc_symbol_name_hash(sym.name);
            tbl->sym_names_next[i] = tbl->sym_names_hash[h];
            tbl->sym_names_hash[h] = i;
        }
    }
}

static int find_by_name_in_sym_table(DWARFCache * cache, char * name, Symbol ** res) {
    unsigned m = 0;
    unsigned h = calc_symbol_name_hash(name);
    unsigned cnt = 0;
    Context * prs = context_get_group(sym_ctx, CONTEXT_GROUP_PROCESS);
    for (m = 1; m < cache->mFile->section_cnt; m++) {
        unsigned n;
        ELF_Section * tbl = cache->mFile->sections + m;
        if (tbl->sym_count == 0) continue;
        if (tbl->sym_names_hash == NULL) create_symbol_names_hash(tbl);
        n = tbl->sym_names_hash[h];
        while (n) {
            ELF_SymbolInfo sym_info;
            unpack_elf_symbol_info(tbl, n, &sym_info);
            if (cmp_symbol_names(name, sym_info.name) == 0) {
                int found = 0;
                ContextAddress addr = 0;
                if (sym_info.section_index != SHN_ABS && syminfo2address(prs, &sym_info, &addr) == 0) {
                    UnitAddressRange * range = elf_find_unit(sym_ctx, addr, addr, NULL);
                    if (range != NULL) {
                        ObjectInfo * obj = range->mUnit->mObject->mChildren;
                        while (obj != NULL) {
                            switch (obj->mTag) {
                            case TAG_global_subroutine:
                            case TAG_global_variable:
                            case TAG_subroutine:
                            case TAG_subprogram:
                            case TAG_variable:
                                if (obj->mName != NULL && strcmp(obj->mName, name) == 0) {
                                    object2symbol(obj, res);
                                    found = 1;
                                    cnt++;
                                }
                                break;
                            }
                            obj = obj->mSibling;
                        }
                    }
                }
                if (!found) {
                    Symbol * sym = alloc_symbol();
                    sym->frame = STACK_NO_FRAME;
                    sym->ctx = prs;
                    sym->tbl = tbl;
                    sym->index = n;
                    switch (sym_info.type) {
                    case STT_FUNC:
                        sym->sym_class = SYM_CLASS_FUNCTION;
                        break;
                    case STT_OBJECT:
                        sym->sym_class = SYM_CLASS_REFERENCE;
                        break;
                    default:
                        sym->sym_class = SYM_CLASS_VALUE;
                        break;
                    }
                    *res = sym;
                    cnt++;
                }
            }
            n = tbl->sym_names_next[n];
        }
    }
    return cnt == 1;
}

int find_symbol_by_name(Context * ctx, int frame, ContextAddress ip, char * name, Symbol ** res) {
    int error = 0;
    int found = 0;

    assert(ctx != NULL);

#if defined(_WRS_KERNEL)
    {
        char * ptr;
        SYM_TYPE type;

        if (symFindByName(sysSymTbl, name, &ptr, &type) != OK) {
            error = errno;
            assert(error != 0);
            if (error == S_symLib_SYMBOL_NOT_FOUND) error = 0;
        }
        else {
            Symbol * sym = alloc_symbol();
            sym->ctx = context_get_group(ctx, CONTEXT_GROUP_PROCESS);
            sym->frame = STACK_NO_FRAME;
            sym->address = (ContextAddress)ptr;
            sym->has_address = 1;

            if (SYM_IS_TEXT(type)) {
                sym->sym_class = SYM_CLASS_FUNCTION;
            }
            else {
                sym->sym_class = SYM_CLASS_REFERENCE;
            }
            *res = sym;
            found = 1;
        }
    }
#endif

    if (error == 0 && !found && get_sym_context(ctx, frame, ip) < 0) error = errno;

    if (error == 0 && !found && sym_ip != 0) {
        Trap trap;
        if (set_trap(&trap)) {
            found = find_in_dwarf(name, res);
            clear_trap(&trap);
        }
        else {
            error = trap.error;
        }
    }

    if (error == 0 && !found) {
        ELF_File * file = elf_list_first(sym_ctx, sym_ip, sym_ip ? sym_ip : ~(ContextAddress)0);
        if (file == NULL) error = errno;
        while (error == 0 && file != NULL) {
            Trap trap;
            if (set_trap(&trap)) {
                DWARFCache * cache = get_dwarf_cache(file);
                if (cache->mPubNames.mHash != NULL) {
                    found = find_by_name_in_pub_names(cache, &cache->mPubNames, name, res);
                    if (!found && cache->mPubTypes.mHash != NULL) {
                        found = find_by_name_in_pub_names(cache, &cache->mPubTypes, name, res);
                    }
                }
                if (!found) {
                    found = find_by_name_in_sym_table(cache, name, res);
                }
                clear_trap(&trap);
            }
            else {
                error = trap.error;
                break;
            }
            if (found) break;
            file = elf_list_next(sym_ctx);
            if (file == NULL) error = errno;
        }
        elf_list_done(sym_ctx);
    }

    if (error == 0 && !found && sym_ip != 0) {
        Trap trap;
        if (set_trap(&trap)) {
            const char * s = NULL;
            if (strcmp(name, "signed") == 0) s = "int";
            else if (strcmp(name, "signed int") == 0) s = "int";
            else if (strcmp(name, "unsigned") == 0) s = "unsigned int";
            else if (strcmp(name, "short") == 0) s = "short int";
            else if (strcmp(name, "signed short") == 0) s = "short int";
            else if (strcmp(name, "signed short int") == 0) s = "short int";
            else if (strcmp(name, "unsigned short") == 0) s = "unsigned short int";
            else if (strcmp(name, "long") == 0) s = "long int";
            else if (strcmp(name, "signed long") == 0) s = "long int";
            else if (strcmp(name, "signed long int") == 0) s = "long int";
            else if (strcmp(name, "unsigned long") == 0) s = "unsigned long int";
            else if (strcmp(name, "long long") == 0) s = "long long int";
            else if (strcmp(name, "signed long long") == 0) s = "long long int";
            else if (strcmp(name, "signed long long int") == 0) s = "long long int";
            else if (strcmp(name, "unsigned long long") == 0) s = "unsigned long long int";
            else if (strcmp(name, "char") == 0) s = "signed char";
            if (s != NULL) {
                found = find_in_dwarf(s, res);
                if (!found) {
                    s = NULL;
                    if (strcmp(name, "char") == 0) s = "unsigned char";
                    if (s != NULL) found = find_in_dwarf(s, res);
                }
            }
            clear_trap(&trap);
        }
        else {
            error = trap.error;
        }
    }

#if ENABLE_RCBP_TEST
    if (!found) {
        int sym_class = 0;
        void * address = NULL;
        found = find_test_symbol(ctx, name, &address, &sym_class) >= 0;
        if (found) {
            Symbol * sym = alloc_symbol();
            sym->ctx = context_get_group(ctx, CONTEXT_GROUP_PROCESS);
            sym->frame = STACK_NO_FRAME;
            sym->address = (ContextAddress)address;
            sym->has_address = 1;
            sym->sym_class = sym_class;
            *res = sym;
        }
    }
#endif

    if (error == 0 && !found) {
        /* Search all compilation units */
        ELF_File * file = elf_list_first(sym_ctx, 0, ~(ContextAddress)0);
        if (file == NULL) error = errno;
        while (error == 0 && file != NULL) {
            Trap trap;
            if (set_trap(&trap)) {
                unsigned i;
                DWARFCache * cache = get_dwarf_cache(file);
                for (i = 0; i < cache->mAddrRangesCnt; i++) {
                    UnitAddressRange * range = cache->mAddrRanges + i;
                    CompUnit * unit = range->mUnit;
                    ContextAddress rt_addr = elf_map_to_run_time_address(sym_ctx, file, unit->mTextSection, range->mAddr);
                    if (rt_addr != 0) {
                        *res = NULL;
                        sym_ip = rt_addr;
                        if (find_in_object_tree(unit->mObject->mChildren, rt_addr - range->mAddr, sym_ip, name, res)) found = 1;
                        if (!found && unit->mBaseTypes != NULL) {
                            if (find_in_object_tree(unit->mBaseTypes->mObject->mChildren, 0, 0, name, res)) found = 1;
                        }
                        if (found) break;
                    }
                }
                clear_trap(&trap);
            }
            else {
                error = trap.error;
                break;
            }
            if (found) break;
            file = elf_list_next(sym_ctx);
            if (file == NULL) error = errno;
        }
        elf_list_done(sym_ctx);
        sym_ip = 0;
    }

    if (error == 0 && !found) error = ERR_SYM_NOT_FOUND;

    assert(error || (*res != NULL && (*res)->ctx != NULL));

    if (error) {
        errno = error;
        return -1;
    }
    return 0;
}

int find_symbol_in_scope(Context * ctx, int frame, ContextAddress ip, Symbol * scope, char * name, Symbol ** res) {
    int error = 0;
    int found = 0;

    *res = NULL;
    if (get_sym_context(ctx, frame, ip) < 0) error = errno;

    if (!error && scope == NULL && sym_ip != 0) {
        ELF_File * file = elf_list_first(sym_ctx, sym_ip, sym_ip);
        if (file == NULL) error = errno;
        while (error == 0 && file != NULL) {
            Trap trap;
            if (set_trap(&trap)) {
                DWARFCache * cache = get_dwarf_cache(file);
                UnitAddressRange * range = find_comp_unit_addr_range(cache, sym_ip, sym_ip);
                if (range != NULL) {
                    found = find_in_object_tree(range->mUnit->mObject->mChildren, 0, 0, name, res);
                }
                if (!found) {
                    found = find_by_name_in_sym_table(cache, name, res);
                }
                clear_trap(&trap);
            }
            else {
                error = trap.error;
                break;
            }
            if (found) break;
            file = elf_list_next(sym_ctx);
            if (file == NULL) error = errno;
        }
        elf_list_done(sym_ctx);
    }

    if (!found && !error && scope != NULL && scope->obj != NULL) {
        Trap trap;
        if (set_trap(&trap)) {
            found = find_in_object_tree(scope->obj->mChildren, 0, 0, name, res);
            clear_trap(&trap);
        }
        else {
            error = trap.error;
        }
    }

    if (error == 0 && !found) error = ERR_SYM_NOT_FOUND;

    assert(error || (*res != NULL && (*res)->ctx != NULL));

    if (error) {
        errno = error;
        return -1;
    }
    return 0;
}

static int find_by_addr_in_unit(ObjectInfo * obj, int level, ContextAddress rt_offs, ContextAddress addr, Symbol ** res) {
    while (obj != NULL) {
        switch (obj->mTag) {
        case TAG_global_subroutine:
        case TAG_subroutine:
        case TAG_subprogram:
        case TAG_entry_point:
        case TAG_lexical_block:
        case TAG_inlined_subroutine:
            if (check_in_range(obj, rt_offs, addr)) {
                object2symbol(obj, res);
                return 1;
            }
            if (check_in_range(obj, rt_offs, sym_ip)) {
                return find_by_addr_in_unit(obj->mChildren, level + 1, rt_offs, addr, res);
            }
            break;
        case TAG_formal_parameter:
        case TAG_unspecified_parameters:
        case TAG_local_variable:
            if (sym_frame == STACK_NO_FRAME) break;
        case TAG_variable:
            {
                U8_T lc = 0;
                /* Ignore location evaluation errors. For example, the error can be caused by
                 * the object not being mapped into the context memory */
                if (get_num_prop(obj, AT_location, &lc) && lc <= addr) {
                    U8_T sz = 0;
                    if (!get_num_prop(obj, AT_byte_size, &sz)) {
                        /* If object size unknown, continue search */
                        if (get_error_code(errno) == ERR_SYM_NOT_FOUND) break;
                        exception(errno);
                    }
                    if (lc + sz > addr) {
                        object2symbol(obj, res);
                        return 1;
                    }
                }
            }
            break;
        }
        obj = obj->mSibling;
    }
    return 0;
}

static int find_by_addr_in_sym_tables(ContextAddress addr, Symbol ** res) {
    ELF_File * file = NULL;
    ELF_Section * section = NULL;
    ELF_SymbolInfo sym_info;
    ContextAddress lt_addr = elf_map_to_link_time_address(sym_ctx, addr, &file, &section);
    elf_find_symbol_by_address(section, lt_addr, &sym_info);
    while (sym_info.sym_section != NULL) {
        int sym_class = SYM_CLASS_UNKNOWN;
        assert(sym_info.section == section);
        switch (sym_info.type) {
        case STT_FUNC:
            sym_class = SYM_CLASS_FUNCTION;
            break;
        case STT_OBJECT:
            sym_class = SYM_CLASS_REFERENCE;
            break;
        }
        if (sym_class != SYM_CLASS_UNKNOWN) {
            ContextAddress sym_addr = sym_info.value;
            if (file->type == ET_REL) sym_addr += section->addr;
            assert(sym_addr <= lt_addr);
            if (sym_addr + sym_info.size > lt_addr) {
                Symbol * sym = alloc_symbol();
                sym->frame = STACK_NO_FRAME;
                sym->ctx = context_get_group(sym_ctx, CONTEXT_GROUP_PROCESS);
                sym->tbl = sym_info.sym_section;
                sym->index = sym_info.sym_index;
                sym->sym_class = sym_class;
                *res = sym;
                return 1;
            }
            return 0;
        }
        elf_prev_symbol_by_address(&sym_info);
    }
    return 0;
}

int find_symbol_by_addr(Context * ctx, int frame, ContextAddress addr, Symbol ** res) {
    Trap trap;
    int found = 0;
    ContextAddress rt_addr = 0;
    UnitAddressRange * range = NULL;
    if (!set_trap(&trap)) return -1;
    if (frame == STACK_TOP_FRAME && (frame = get_top_frame(ctx)) < 0) exception(errno);
    if (get_sym_context(ctx, frame, addr) < 0) exception(errno);
    range = elf_find_unit(sym_ctx, addr, addr, &rt_addr);
    if (range != NULL) found = find_by_addr_in_unit(range->mUnit->mObject->mChildren,
        0, rt_addr - range->mAddr, addr, res);
    if (!found) found = find_by_addr_in_sym_tables(addr, res);
    if (!found && sym_ip != 0) {
        /* Search in compilation unit that contains stack frame PC */
        range = elf_find_unit(sym_ctx, sym_ip, sym_ip, &rt_addr);
        if (range != NULL) found = find_by_addr_in_unit(range->mUnit->mObject->mChildren,
            0, rt_addr - range->mAddr, addr, res);
    }
    if (!found) exception(ERR_SYM_NOT_FOUND);
    clear_trap(&trap);
    return 0;
}

static void enumerate_local_vars(ObjectInfo * obj, int level, ContextAddress rt_offs,
                                 EnumerateSymbolsCallBack * call_back, void * args) {
    while (obj != NULL) {
        switch (obj->mTag) {
        case TAG_global_subroutine:
        case TAG_subroutine:
        case TAG_subprogram:
        case TAG_entry_point:
        case TAG_lexical_block:
        case TAG_inlined_subroutine:
            if (check_in_range(obj, rt_offs, sym_ip)) {
                enumerate_local_vars(obj->mChildren, level + 1, rt_offs, call_back, args);
            }
            break;
        case TAG_formal_parameter:
        case TAG_unspecified_parameters:
        case TAG_local_variable:
        case TAG_variable:
            if (level > 0) {
                Context * org_ctx = sym_ctx;
                int org_frame = sym_frame;
                ContextAddress org_ip = sym_ip;
                Symbol * sym = NULL;
                object2symbol(obj, &sym);
                call_back(args, sym);
                sym_ctx = org_ctx;
                sym_frame = org_frame;
                sym_ip = org_ip;
            }
            break;
        }
        obj = obj->mSibling;
    }
}

int enumerate_symbols(Context * ctx, int frame, EnumerateSymbolsCallBack * call_back, void * args) {
    Trap trap;
    if (!set_trap(&trap)) return -1;
    if (frame == STACK_TOP_FRAME && (frame = get_top_frame(ctx)) < 0) exception(errno);
    if (get_sym_context(ctx, frame, 0) < 0) exception(errno);
    if (sym_ip != 0) {
        ContextAddress rt_addr = 0;
        UnitAddressRange * range = elf_find_unit(sym_ctx, sym_ip, sym_ip, &rt_addr);
        if (range != NULL) enumerate_local_vars(range->mUnit->mObject->mChildren,
            0, rt_addr - range->mAddr, call_back, args);
    }
    clear_trap(&trap);
    return 0;
}

const char * symbol2id(const Symbol * sym) {
    static char id[256];

    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base) {
        char base[256];
        assert(sym->ctx == sym->base->ctx);
        assert(sym->frame == STACK_NO_FRAME);
        assert(sym->sym_class == SYM_CLASS_TYPE);
        strcpy(base, symbol2id(sym->base));
        snprintf(id, sizeof(id), "@P%"PRIX64".%s", (uint64_t)sym->length, base);
    }
    else {
        ELF_File * file = NULL;
        uint64_t obj_index = 0;
        uint64_t var_index = 0;
        unsigned tbl_index = 0;
        int frame = sym->frame;
        if (sym->obj != NULL) file = sym->obj->mCompUnit->mFile;
        if (sym->tbl != NULL) file = sym->tbl->file;
        if (sym->obj != NULL) obj_index = sym->obj->mID;
        if (sym->var != NULL) var_index = sym->var->mID;
        if (sym->tbl != NULL) tbl_index = sym->tbl->index;
        if (frame == STACK_TOP_FRAME) frame = get_top_frame(sym->ctx);
        assert(sym->var == NULL || sym->var->mCompUnit->mFile == file);
        snprintf(id, sizeof(id), "@S%X.%lX.%lX.%"PRIX64".%"PRIX64".%"PRIX64".%X.%d.%X.%X.%X.%s",
            sym->sym_class,
            file ? (unsigned long)file->dev : 0ul,
            file ? (unsigned long)file->ino : 0ul,
            file ? file->mtime : (int64_t)0,
            obj_index, var_index, tbl_index,
            frame, sym->index,
            sym->dimension, sym->cardinal,
            sym->ctx->id);
    }
    return id;
}

static uint64_t read_hex(const char ** s) {
    uint64_t res = 0;
    const char * p = *s;
    for (;;) {
        if (*p >= '0' && *p <= '9') res = (res << 4) | (*p - '0');
        else if (*p >= 'A' && *p <= 'F') res = (res << 4) | (*p - 'A' + 10);
        else break;
        p++;
    }
    *s = p;
    return res;
}

static int read_int(const char ** s) {
    int neg = 0;
    int res = 0;
    const char * p = *s;
    if (*p == '-') {
        neg = 1;
        p++;
    }
    for (;;) {
        if (*p >= '0' && *p <= '9') res = res * 10 + (*p - '0');
        else break;
        p++;
    }
    *s = p;
    return neg ? -res : res;
}

int id2symbol(const char * id, Symbol ** res) {
    Symbol * sym = alloc_symbol();
    dev_t dev = 0;
    ino_t ino = 0;
    int64_t mtime;
    uint64_t obj_index = 0;
    uint64_t var_index = 0;
    unsigned tbl_index = 0;
    ELF_File * file = NULL;
    const char * p;
    Trap trap;

    *res = sym;
    if (id != NULL && id[0] == '@' && id[1] == 'P') {
        p = id + 2;
        sym->length = (ContextAddress)read_hex(&p);
        if (*p == '.') p++;
        if (id2symbol(p, &sym->base)) return -1;
        sym->ctx = sym->base->ctx;
        sym->frame = STACK_NO_FRAME;
        sym->sym_class = SYM_CLASS_TYPE;
        return 0;
    }
    else if (id != NULL && id[0] == '@' && id[1] == 'S') {
        p = id + 2;
        sym->sym_class = (int)read_hex(&p);
        if (*p == '.') p++;
        dev = (dev_t)read_hex(&p);
        if (*p == '.') p++;
        ino = (ino_t)read_hex(&p);
        if (*p == '.') p++;
        mtime = (int64_t)read_hex(&p);
        if (*p == '.') p++;
        obj_index = read_hex(&p);
        if (*p == '.') p++;
        var_index = read_hex(&p);
        if (*p == '.') p++;
        tbl_index = (unsigned)read_hex(&p);
        if (*p == '.') p++;
        sym->frame = read_int(&p);
        if (*p == '.') p++;
        sym->index = (unsigned)read_hex(&p);
        if (*p == '.') p++;
        sym->dimension = (unsigned)read_hex(&p);
        if (*p == '.') p++;
        sym->cardinal = (unsigned)read_hex(&p);
        if (*p == '.') p++;
        sym->ctx = id2ctx(p);
        if (sym->ctx == NULL) {
            errno = ERR_INV_CONTEXT;
            return -1;
        }
        if (dev == 0 && ino == 0 && mtime == 0) return 0;
        file = elf_open_inode(sym->ctx, dev, ino, mtime);
        if (file == NULL) return -1;
        if (set_trap(&trap)) {
            DWARFCache * cache = get_dwarf_cache(file);
            if (obj_index) {
                sym->obj = find_object(cache, obj_index);
                if (sym->obj == NULL) exception(ERR_INV_CONTEXT);
            }
            if (var_index) {
                sym->var = find_object(cache, var_index);
                if (sym->var == NULL) exception(ERR_INV_CONTEXT);
            }
            if (tbl_index) {
                if (tbl_index >= file->section_cnt) exception(ERR_INV_CONTEXT);
                sym->tbl = file->sections + tbl_index;
            }
            clear_trap(&trap);
            return 0;
        }
    }
    else {
        errno = ERR_INV_CONTEXT;
    }
    return -1;
}

ContextAddress is_plt_section(Context * ctx, ContextAddress addr) {
    ELF_File * file = NULL;
    ELF_Section * sec = NULL;
    ContextAddress res = elf_map_to_link_time_address(ctx, addr, &file, &sec);
    if (res == 0 || sec == NULL) return 0;
    if (sec->name == NULL) return 0;
    if (strcmp(sec->name, ".plt") != 0) return 0;
    return sec->addr + (addr - res);
}

int get_stack_tracing_info(Context * ctx, ContextAddress rt_addr, StackTracingInfo ** info) {
    /* TODO: no debug info exists for linux-gate.so, need to read stack tracing information from the kernel  */
    /* TODO: support for separate debug info files */
    ELF_File * file = NULL;
    ELF_Section * sec = NULL;
    ContextAddress lt_addr = 0;
    int error = 0;
    Trap trap;

    *info = NULL;

    lt_addr = elf_map_to_link_time_address(ctx, rt_addr, &file, &sec);
    if (file != NULL) {
        /* This assert fails because of ambiguity in Linux memory maps:
         * assert(rt_addr == elf_map_to_run_time_address(ctx, file, sec, lt_addr)); */
        if (set_trap(&trap)) {
            get_dwarf_stack_frame_info(ctx, file, sec, lt_addr);
            if (dwarf_stack_trace_fp->cmds_cnt > 0) {
                static StackTracingInfo buf;
                buf.addr = (ContextAddress)dwarf_stack_trace_addr - lt_addr + rt_addr;
                buf.size = (ContextAddress)dwarf_stack_trace_size;
                buf.fp = dwarf_stack_trace_fp;
                buf.regs = dwarf_stack_trace_regs;
                buf.reg_cnt = dwarf_stack_trace_regs_cnt;
                *info = &buf;
            }
            clear_trap(&trap);
        }
        else {
            error = trap.error;
        }
    }

    if (error) {
        errno = error;
        return -1;
    }
    return 0;
}

int get_next_stack_frame(StackFrame * frame, StackFrame * down) {
    int error = 0;
    uint64_t ip = 0;
    Context * ctx = frame->ctx;
    StackTracingInfo * info = NULL;

    if (read_reg_value(frame, get_PC_definition(ctx), &ip) < 0) {
        if (frame->is_top_frame) error = errno;
    }
    else if (get_stack_tracing_info(ctx, ip, &info) < 0) {
        error = errno;
    }
    else if (info != NULL) {
        Trap trap;
        if (set_trap(&trap)) {
            int i;
            frame->fp = (ContextAddress)evaluate_stack_trace_commands(ctx, frame, info->fp);
            for (i = 0; i < info->reg_cnt; i++) {
                int ok = 0;
                uint64_t v = 0;
                Trap trap_reg;
                if (set_trap(&trap_reg)) {
                    /* If a saved register value cannot be evaluated - ignore it */
                    v = evaluate_stack_trace_commands(ctx, frame, info->regs[i]);
                    clear_trap(&trap_reg);
                    ok = 1;
                }
                if (ok && write_reg_value(down, info->regs[i]->reg, v) < 0) exception(errno);
            }
            clear_trap(&trap);
        }
        else {
            frame->fp = 0;
        }
    }
    if (error) {
        errno = error;
        return -1;
    }
    return 0;
}

void ini_symbols_lib(void) {
}

/*************** Functions for retrieving symbol properties ***************************************/

static int unpack(const Symbol * sym) {
    ELF_File * file = NULL;
    assert(sym->base == NULL);
    assert(!is_cardinal_type_pseudo_symbol(sym));
    if (get_sym_context(sym->ctx, sym->frame, 0) < 0) return -1;
    if (sym->obj != NULL) file = sym->obj->mCompUnit->mFile;
    if (sym->tbl != NULL) file = sym->tbl->file;
    if (file != NULL) {
        DWARFCache * cache = (DWARFCache *)file->dwarf_dt_cache;
        if (cache == NULL || cache->magic != DWARF_CACHE_MAGIC) {
            errno = ERR_INV_CONTEXT;
            return -1;
        }
    }
    return 0;
}

static U8_T get_default_lower_bound(ObjectInfo * obj) {
    switch (obj->mCompUnit->mLanguage) {
    case LANG_FORTRAN77:
    case LANG_FORTRAN90:
    case LANG_FORTRAN95:
        return 1;
    }
    return 0;
}

static U8_T get_object_length(ObjectInfo * obj) {
    U8_T x, y;

    if (get_num_prop(obj, AT_count, &x)) return x;
    if (get_num_prop(obj, AT_upper_bound, &x)) {
        if (!get_num_prop(obj, AT_lower_bound, &y)) {
            y = get_default_lower_bound(obj);
        }
        return x + 1 - y;
    }
    if (obj->mTag == TAG_enumeration_type) {
        ObjectInfo * c = obj->mChildren;
        x = 0;
        while (c != NULL) {
            x++;
            c = c->mSibling;
        }
        return x;
    }
    return 0;
}

static void alloc_cardinal_type_pseudo_symbol(Context * ctx, unsigned size, Symbol ** type) {
    *type = alloc_symbol();
    (*type)->ctx = context_get_group(ctx, CONTEXT_GROUP_PROCESS);
    (*type)->frame = STACK_NO_FRAME;
    (*type)->sym_class = SYM_CLASS_TYPE;
    (*type)->cardinal = size;
}

static int map_to_sym_table(ObjectInfo * obj, Symbol ** sym) {
    U8_T v = 0;
    int found = 0;
    if (get_num_prop(obj, AT_external, &v) && v != 0) {
        Trap trap;
        if (set_trap(&trap)) {
            PropertyValue p;
            DWARFCache * cache = get_dwarf_cache(obj->mCompUnit->mFile);
            read_and_evaluate_dwarf_object_property(sym_ctx, sym_frame, 0, obj, AT_MIPS_linkage_name, &p);
            if (p.mAddr != NULL) found = find_by_name_in_sym_table(cache, (char *)p.mAddr, sym);
            clear_trap(&trap);
        }
    }
    return found;
}

int get_symbol_class(const Symbol * sym, int * sym_class) {
    assert(sym->magic == SYMBOL_MAGIC);
    *sym_class = sym->sym_class;
    return 0;
}

int get_symbol_type(const Symbol * sym, Symbol ** type) {
    ObjectInfo * obj = sym->obj;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base || is_cardinal_type_pseudo_symbol(sym)) {
        *type = (Symbol *)sym;
        return 0;
    }
    if (sym->sym_class == SYM_CLASS_FUNCTION) {
        *type = alloc_symbol();
        (*type)->ctx = sym->ctx;
        (*type)->frame = STACK_NO_FRAME;
        (*type)->sym_class = SYM_CLASS_TYPE;
        (*type)->base = (Symbol *)sym;
        return 0;
    }
    if (unpack(sym) < 0) return -1;
    obj = sym->sym_class == SYM_CLASS_TYPE ?
        get_original_type(obj) : get_object_type(obj);
    if (obj == NULL) {
        *type = NULL;
    }
    else if (obj == sym->obj) {
        *type = (Symbol *)sym;
    }
    else {
        object2symbol(obj, type);
    }
    return 0;
}

int get_symbol_type_class(const Symbol * sym, int * type_class) {
    U8_T x;
    ObjectInfo * obj = sym->obj;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base) {
        if (sym->base->sym_class == SYM_CLASS_FUNCTION) *type_class = TYPE_CLASS_FUNCTION;
        else if (sym->length > 0) *type_class = TYPE_CLASS_ARRAY;
        else *type_class = TYPE_CLASS_POINTER;
        return 0;
    }
    if (is_cardinal_type_pseudo_symbol(sym)) {
        *type_class = TYPE_CLASS_CARDINAL;
        return 0;
    }
    if (unpack(sym) < 0) return -1;
    while (obj != NULL) {
        switch (obj->mTag) {
        case TAG_global_subroutine:
        case TAG_subroutine:
        case TAG_subprogram:
        case TAG_entry_point:
        case TAG_subroutine_type:
            *type_class = TYPE_CLASS_FUNCTION;
            return 0;
        case TAG_array_type:
        case TAG_string_type:
            *type_class = TYPE_CLASS_ARRAY;
            return 0;
        case TAG_enumeration_type:
        case TAG_enumerator:
            *type_class = TYPE_CLASS_ENUMERATION;
            return 0;
        case TAG_pointer_type:
        case TAG_reference_type:
        case TAG_mod_pointer:
        case TAG_mod_reference:
            *type_class = TYPE_CLASS_POINTER;
            return 0;
        case TAG_class_type:
        case TAG_structure_type:
        case TAG_union_type:
        case TAG_interface_type:
            *type_class = TYPE_CLASS_COMPOSITE;
            return 0;
        case TAG_base_type:
            if (get_num_prop(obj, AT_encoding, &x)) {
                switch ((int)x) {
                case ATE_address:
                    *type_class = TYPE_CLASS_POINTER;
                    return 0;
                case ATE_boolean:
                    *type_class = TYPE_CLASS_INTEGER;
                    return 0;
                case ATE_float:
                    *type_class = TYPE_CLASS_REAL;
                    return 0;
                case ATE_signed:
                case ATE_signed_char:
                    *type_class = TYPE_CLASS_INTEGER;
                    return 0;
                case ATE_unsigned:
                case ATE_unsigned_char:
                    *type_class = TYPE_CLASS_CARDINAL;
                    return 0;
                }
            }
            *type_class = TYPE_CLASS_UNKNOWN;
            return 0;
        case TAG_fund_type:
            switch (obj->u.mFundType) {
            case FT_boolean:
                *type_class = TYPE_CLASS_INTEGER;
                return 0;
            case FT_char:
                *type_class = TYPE_CLASS_INTEGER;
                return 0;
            case FT_dbl_prec_float:
            case FT_ext_prec_float:
            case FT_float:
                *type_class = TYPE_CLASS_REAL;
                return 0;
            case FT_signed_char:
            case FT_signed_integer:
            case FT_signed_long:
            case FT_signed_short:
            case FT_short:
            case FT_integer:
            case FT_long:
                *type_class = TYPE_CLASS_INTEGER;
                return 0;
            case FT_unsigned_char:
            case FT_unsigned_integer:
            case FT_unsigned_long:
            case FT_unsigned_short:
                *type_class = TYPE_CLASS_CARDINAL;
                return 0;
            case FT_pointer:
                *type_class = TYPE_CLASS_POINTER;
                return 0;
            case FT_void:
                *type_class = TYPE_CLASS_CARDINAL;
                return 0;
            case FT_label:
            case FT_complex:
            case FT_dbl_prec_complex:
            case FT_ext_prec_complex:
                break;
            }
            *type_class = TYPE_CLASS_UNKNOWN;
            return 0;
        case TAG_subrange_type:
        case TAG_packed_type:
        case TAG_volatile_type:
        case TAG_restrict_type:
        case TAG_shared_type:
        case TAG_const_type:
        case TAG_typedef:
        case TAG_formal_parameter:
        case TAG_unspecified_parameters:
        case TAG_global_variable:
        case TAG_local_variable:
        case TAG_variable:
        case TAG_inheritance:
        case TAG_member:
        case TAG_constant:
            obj = obj->mType;
            break;
        default:
            obj = NULL;
            break;
        }
    }
    if (sym->tbl != NULL) {
        ELF_SymbolInfo info;
        unpack_elf_symbol_info(sym->tbl, sym->index, &info);
        if (info.type == STT_FUNC) {
            *type_class = TYPE_CLASS_FUNCTION;
            return 0;
        }
    }
    *type_class = TYPE_CLASS_UNKNOWN;
    return 0;
}

int get_symbol_update_policy(const Symbol * sym, char ** id, int * policy) {
    assert(sym->magic == SYMBOL_MAGIC);
    *id = sym->ctx->id;
    *policy = context_has_state(sym->ctx) ? UPDATE_ON_EXE_STATE_CHANGES : UPDATE_ON_MEMORY_MAP_CHANGES;
    return 0;
}

int get_symbol_name(const Symbol * sym, char ** name) {
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base || is_cardinal_type_pseudo_symbol(sym)) {
        *name = NULL;
    }
    else if (sym->obj != NULL) {
        *name = sym->obj->mName;
    }
    else if (sym->tbl != NULL) {
        ELF_SymbolInfo info;
        unpack_elf_symbol_info(sym->tbl, sym->index, &info);
        *name = info.name;
    }
    else {
        *name = NULL;
    }
    return 0;
}

int get_symbol_size(const Symbol * sym, ContextAddress * size) {
    ObjectInfo * obj = sym->obj;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base) {
        if (sym->length > 0) {
            if (get_symbol_size(sym->base, size)) return -1;
            *size *= sym->length;
        }
        else {
            Symbol * base = sym->base;
            while (base->obj == NULL && base->base != NULL) base = base->base;
            if (base->obj != NULL) *size = base->obj->mCompUnit->mDesc.mAddressSize;
            else *size = context_word_size(sym->ctx);
        }
        return 0;
    }
    if (is_cardinal_type_pseudo_symbol(sym)) {
        *size = sym->cardinal;
        return 0;
    }
    if (sym->has_size != 0) {
        *size = sym->size;
        return 0;
    }
    if (unpack(sym) < 0) return -1;
    *size = 0;
    if (obj != NULL) {
        Trap trap;
        int ok = 0;
        U8_T sz = 0;

        if (!set_trap(&trap)) return -1;
        if (sym->dimension == 0) ok = get_num_prop(obj, AT_byte_size, &sz);
        if (!ok && sym->sym_class == SYM_CLASS_FUNCTION) {
            if (obj->u.mAddr.mHighPC > obj->u.mAddr.mLowPC) {
                ok = 1;
                sz = obj->u.mAddr.mHighPC - obj->u.mAddr.mLowPC;
            }
        }
        else if (!ok) {
            ObjectInfo * ref = NULL;
            if (sym->sym_class == SYM_CLASS_REFERENCE) {
                ref = obj;
                if (obj->mType != NULL) {
                    obj = obj->mType;
                    if (sym->dimension == 0) ok = get_num_prop(obj, AT_byte_size, &sz);
                }
            }
            while (!ok && obj->mType != NULL) {
                if (!is_modified_type(obj) && obj->mTag != TAG_enumeration_type) break;
                obj = obj->mType;
                if (sym->dimension == 0) ok = get_num_prop(obj, AT_byte_size, &sz);
            }
            if (!ok && obj->mTag == TAG_array_type) {
                unsigned i = 0;
                U8_T length = 1;
                ObjectInfo * elem_type = obj->mType;
                ObjectInfo * idx = obj->mChildren;
                while (idx != NULL) {
                    if (i++ >= sym->dimension) length *= get_object_length(idx);
                    idx = idx->mSibling;
                }
                ok = get_num_prop(obj, AT_stride_size, &sz);
                if (ok) {
                    sz = (sz * length + 7) / 8;
                }
                else {
                    if (elem_type == NULL) str_exception(ERR_OTHER, "Unknown array element type");
                    ok = get_num_prop(elem_type, AT_byte_size, &sz);
                    while (!ok && elem_type->mType != NULL) {
                        if (!is_modified_type(elem_type) && elem_type->mTag != TAG_enumeration_type) break;
                        elem_type = elem_type->mType;
                        ok = get_num_prop(elem_type, AT_byte_size, &sz);
                    }
                    if (ok) sz *= length;
                }
            }
            if (!ok && ref && ref->mTag != TAG_member && ref->mTag != TAG_inheritance) {
                Trap trap;
                if (set_trap(&trap)) {
                    PropertyValue v;
                    read_and_evaluate_dwarf_object_property(sym_ctx, sym_frame, 0, ref, AT_location, &v);
                    if (v.mRegister) {
                        sz = v.mRegister->size;
                        ok = 1;
                    }
                    clear_trap(&trap);
                }
            }
            if (!ok && ref != NULL) {
                Symbol * elf_sym = NULL;
                ContextAddress elf_sym_size = 0;
                if (map_to_sym_table(ref, &elf_sym) && get_symbol_size(elf_sym, &elf_sym_size) == 0) {
                    sz = elf_sym_size;
                    ok = 1;
                }
            }
        }
        if (!ok) str_exception(ERR_INV_DWARF, "Object has no size attribute");
        *size = (ContextAddress)sz;
        clear_trap(&trap);
    }
    else if (sym->tbl != NULL) {
        ELF_SymbolInfo info;
        unpack_elf_symbol_info(sym->tbl, sym->index, &info);
        switch (info.type) {
        case STT_OBJECT:
        case STT_FUNC:
            *size = (ContextAddress)info.size;
            break;
        default:
            *size = info.sym_section->file->elf64 ? 8 : 4;
            break;
        }
    }
    else {
        errno = set_errno(ERR_OTHER, "Debug info not available");
        return -1;
    }
    return 0;
}

int get_symbol_base_type(const Symbol * sym, Symbol ** base_type) {
    ObjectInfo * obj = sym->obj;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base) {
        if (sym->base->sym_class == SYM_CLASS_FUNCTION) {
            if (sym->base->obj != NULL && sym->base->obj->mType != NULL) {
                if (unpack(sym->base) < 0) return -1;
                object2symbol(sym->base->obj->mType, base_type);
            }
            else {
                /* Function return type is 'void' */
                alloc_cardinal_type_pseudo_symbol(sym->ctx, 0, base_type);
            }
            return 0;
        }
        *base_type = sym->base;
        return 0;
    }
    if (is_cardinal_type_pseudo_symbol(sym)) {
        errno = ERR_INV_CONTEXT;
        return -1;
    }
    if (unpack(sym) < 0) return -1;
    obj = get_original_type(obj);
    if (obj != NULL) {
        if (obj->mTag == TAG_array_type) {
            int i = sym->dimension;
            ObjectInfo * idx = obj->mChildren;
            while (i > 0 && idx != NULL) {
                idx = idx->mSibling;
                i--;
            }
            if (idx != NULL && idx->mSibling != NULL) {
                *base_type = alloc_symbol();
                **base_type = *sym;
                (*base_type)->dimension++;
                return 0;
            }
        }
        if ((obj->mTag == TAG_pointer_type || obj->mTag == TAG_mod_pointer) && obj->mType == NULL) {
            /* pointer to void */
            alloc_cardinal_type_pseudo_symbol(sym->ctx, 0, base_type);
            return 0;
        }
        obj = obj->mType;
        if (obj != NULL) {
            object2symbol(obj, base_type);
            return 0;
        }
    }
    errno = ERR_UNSUPPORTED;
    return -1;
}

int get_symbol_index_type(const Symbol * sym, Symbol ** index_type) {
    ObjectInfo * obj = sym->obj;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base) {
        if (sym->base->sym_class == SYM_CLASS_FUNCTION) {
            errno = ERR_INV_CONTEXT;
            return -1;
        }
        alloc_cardinal_type_pseudo_symbol(sym->ctx, context_word_size(sym->ctx), index_type);
        return 0;
    }
    if (is_cardinal_type_pseudo_symbol(sym)) {
        errno = ERR_INV_CONTEXT;
        return -1;
    }
    if (unpack(sym) < 0) return -1;
    obj = get_original_type(obj);
    if (obj != NULL && obj->mTag == TAG_array_type) {
        int i = sym->dimension;
        ObjectInfo * idx = obj->mChildren;
        while (i > 0 && idx != NULL) {
            idx = idx->mSibling;
            i--;
        }
        if (idx != NULL) {
            object2symbol(idx, index_type);
            return 0;
        }
    }
    errno = ERR_UNSUPPORTED;
    return -1;
}

int get_symbol_length(const Symbol * sym, ContextAddress * length) {
    ObjectInfo * obj = sym->obj;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base) {
        if (sym->base->sym_class == SYM_CLASS_FUNCTION) {
            errno = ERR_INV_CONTEXT;
            return -1;
        }
        *length = sym->length == 0 ? 1 : sym->length;
        return 0;
    }
    if (is_cardinal_type_pseudo_symbol(sym)) {
        errno = ERR_INV_CONTEXT;
        return -1;
    }
    if (unpack(sym) < 0) return -1;
    obj = get_original_type(obj);
    if (obj != NULL && obj->mTag == TAG_array_type) {
        int i = sym->dimension;
        ObjectInfo * idx = obj->mChildren;
        while (i > 0 && idx != NULL) {
            idx = idx->mSibling;
            i--;
        }
        if (idx != NULL) {
            Trap trap;
            if (!set_trap(&trap)) return -1;
            *length = (ContextAddress)get_object_length(idx);
            clear_trap(&trap);
            return 0;
        }
    }
    errno = ERR_UNSUPPORTED;
    return -1;
}

int get_symbol_lower_bound(const Symbol * sym, int64_t * value) {
    ObjectInfo * obj = sym->obj;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base) {
        if (sym->base->sym_class == SYM_CLASS_FUNCTION) {
            errno = ERR_INV_CONTEXT;
            return -1;
        }
        *value = 0;
        return 0;
    }
    if (is_cardinal_type_pseudo_symbol(sym)) {
        errno = ERR_INV_CONTEXT;
        return -1;
    }
    if (unpack(sym) < 0) return -1;
    obj = get_original_type(obj);
    if (obj != NULL && obj->mTag == TAG_array_type) {
        int i = sym->dimension;
        ObjectInfo * idx = obj->mChildren;
        while (i > 0 && idx != NULL) {
            idx = idx->mSibling;
            i--;
        }
        if (idx != NULL) {
            if (get_num_prop(obj, AT_lower_bound, (U8_T *)value)) return 0;
            if (get_error_code(errno) != ERR_SYM_NOT_FOUND) return -1;
            *value = get_default_lower_bound(obj);
            return 0;
        }
    }
    errno = ERR_UNSUPPORTED;
    return -1;
}

int get_symbol_children(const Symbol * sym, Symbol *** children, int * count) {
    int n = 0;
    static Symbol ** buf = NULL;
    static int buf_len = 0;
    ObjectInfo * obj = sym->obj;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base) {
        if (sym->base->sym_class == SYM_CLASS_FUNCTION && sym->base->obj == NULL) {
            *children = NULL;
            *count = 0;
            errno = ERR_SYM_NOT_FOUND;
            return -1;
        }
        if (sym->base->sym_class == SYM_CLASS_FUNCTION) {
            ObjectInfo * i = sym->base->obj->mChildren;
            if (unpack(sym->base) < 0) return -1;
            while (i != NULL) {
                if (i->mTag == TAG_formal_parameter || i->mTag == TAG_unspecified_parameters) n++;
                i = i->mSibling;
            }
            if (buf_len < n) {
                buf = (Symbol **)loc_realloc(buf, sizeof(Symbol *) * n);
                buf_len = n;
            }
            n = 0;
            i = sym->base->obj->mChildren;
            while (i != NULL) {
                if (i->mTag == TAG_formal_parameter || i->mTag == TAG_unspecified_parameters) {
                    Symbol * x = NULL;
                    Symbol * y = NULL;
                    object2symbol(i, &x);
                    if (get_symbol_type(x, &y) < 0) return -1;
                    buf[n++] = y;
                }
                i = i->mSibling;
            }
            *children = buf;
            *count = n;
            return 0;
        }
        *children = NULL;
        *count = 0;
        return 0;
    }
    if (is_cardinal_type_pseudo_symbol(sym)) {
        *children = NULL;
        *count = 0;
        return 0;
    }
    if (unpack(sym) < 0) return -1;
    obj = get_original_type(obj);
    if (obj != NULL) {
        ObjectInfo * i = obj->mChildren;
        while (i != NULL) {
            i = i->mSibling;
            n++;
        }
        if (buf_len < n) {
            buf = (Symbol **)loc_realloc(buf, sizeof(Symbol *) * n);
            buf_len = n;
        }
        n = 0;
        i = obj->mChildren;
        while (i != NULL) {
            Symbol * x = NULL;
            object2symbol(i, &x);
            buf[n++] = x;
            i = i->mSibling;
        }
    }
    *children = buf;
    *count = n;
    return 0;
}

int get_symbol_offset(const Symbol * sym, ContextAddress * offset) {
    ObjectInfo * obj = sym->obj;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base || is_cardinal_type_pseudo_symbol(sym)) {
        errno = ERR_INV_CONTEXT;
        return -1;
    }
    if (unpack(sym) < 0) return -1;
    if (obj != NULL && (obj->mTag == TAG_member || obj->mTag == TAG_inheritance)) {
        U8_T v;
        if (!get_num_prop(obj, AT_data_member_location, &v)) return -1;
        *offset = (ContextAddress)v;
        return 0;
    }
    errno = ERR_INV_CONTEXT;
    return -1;
}

int get_symbol_value(const Symbol * sym, void ** value, size_t * size, int * big_endian) {
    ObjectInfo * obj = sym->obj;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base || is_cardinal_type_pseudo_symbol(sym) || sym->var) {
        errno = ERR_INV_CONTEXT;
        return -1;
    }
    if (unpack(sym) < 0) return -1;
    if (obj != NULL) {
        Trap trap;
        PropertyValue v;
        static U1_T * bf = NULL;
        static size_t bf_size = 0;
        if (set_trap(&trap)) {
            read_and_evaluate_dwarf_object_property(sym_ctx, sym_frame, 0, obj, AT_const_value, &v);
            if (v.mAddr != NULL) {
                *size = v.mSize;
                *value = v.mAddr;
            }
            else if (v.mRegister != NULL || v.mPieces != NULL) {
                str_exception(ERR_INV_CONTEXT, "Constant DWARF attribute value expected");
            }
            else {
                U8_T n = v.mValue;
                size_t i = 0;
                if (bf_size < sizeof(v.mValue)) {
                    bf_size = sizeof(v.mValue);
                    bf = (U1_T *)loc_realloc(bf, bf_size);
                }
                for (i = 0; i < sizeof(v.mValue); i++) {
                    bf[v.mBigEndian ? sizeof(v.mValue) - i - 1 : i] = n & 0xffu;
                    n = n >> 8;
                }
                *size = sizeof(v.mValue);
                *value = bf;
            }
            *big_endian = v.mBigEndian;
            clear_trap(&trap);
            return 0;
        }
        else if (trap.error != ERR_SYM_NOT_FOUND) {
            return -1;
        }
        if (set_trap(&trap)) {
            read_and_evaluate_dwarf_object_property(sym_ctx, sym_frame, 0, obj, AT_location, &v);
            if (v.mPieces != NULL) {
                U4_T n = 0;
                U4_T bf_offs = 0;
                while (n < v.mPieceCnt) {
                    U4_T i;
                    U1_T pbf[32];
                    PropertyValuePiece * piece = v.mPieces + n++;
                    U4_T piece_size = (piece->mBitSize + 7) / 8;
                    if (piece_size > sizeof(pbf)) exception(ERR_BUFFER_OVERFLOW);
                    if (bf_size < bf_offs / 8 + piece_size + 1) {
                        bf_size = bf_offs / 8 + piece_size + 1;
                        bf = (U1_T *)loc_realloc(bf, bf_size);
                    }
                    if (piece->mRegister) {
                        StackFrame * frame = NULL;
                        RegisterDefinition * def = piece->mRegister;
                        if (get_frame_info(v.mContext, v.mFrame, &frame) < 0) exception(errno);
                        if (read_reg_bytes(frame, def, 0, piece_size, pbf) < 0) exception(errno);
                    }
                    else {
                        if (context_read_mem(v.mContext, piece->mAddress, pbf, piece_size) < 0) exception(errno);
                    }
                    if (!piece->mBigEndian != !v.mBigEndian) swap_bytes(pbf, piece_size);
                    for (i = piece->mBitOffset; i < piece->mBitOffset + piece->mBitSize;  i++) {
                        if (pbf[i / 8] & (1u << (i % 8))) {
                            bf[bf_offs / 8] |=  (1u << (bf_offs % 8));
                        }
                        else {
                            bf[bf_offs / 8] &= ~(1u << (bf_offs % 8));
                        }
                        bf_offs++;
                    }
                }
                while (bf_offs % 8) {
                    bf[bf_offs / 8] &= ~(1u << (bf_offs % 8));
                    bf_offs++;
                }
                *value = bf;
                *size = bf_offs / 8;
                *big_endian = v.mBigEndian;
            }
            else if (v.mRegister != NULL) {
                StackFrame * frame = NULL;
                RegisterDefinition * def = v.mRegister;
                ContextAddress sym_size = def->size;
                unsigned val_offs = 0;
                unsigned val_size = 0;

                if (get_symbol_size(sym, &sym_size) < 0) exception(errno);
                if (bf_size < sym_size) {
                    bf_size = (size_t)sym_size;
                    bf = (U1_T *)loc_realloc(bf, bf_size);
                }
                if (get_frame_info(v.mContext, v.mFrame, &frame) < 0) exception(errno);
                val_size = def->size < sym_size ? (unsigned)def->size : (unsigned)sym_size;
                if (def->big_endian) val_offs = (unsigned)def->size - val_size;
                if (read_reg_bytes(frame, def, val_offs, val_size, bf) < 0) exception(errno);
                *value = bf;
                *size = val_size;
                *big_endian = def->big_endian;
            }
            else {
                exception(ERR_INV_CONTEXT);
            }
            clear_trap(&trap);
            return 0;
        }
        else if (trap.error != ERR_SYM_NOT_FOUND) {
            return -1;
        }
        set_errno(ERR_OTHER, "Object location or value info not available");
        return -1;
    }
    if (sym->tbl != NULL) {
        ELF_SymbolInfo info;
        unpack_elf_symbol_info(sym->tbl, sym->index, &info);
        switch (info.type) {
        case STT_OBJECT:
        case STT_FUNC:
            set_errno(ERR_OTHER, "Symbol represents an address");
            return -1;
        }
        if (info.sym_section->file->elf64) {
            static U8_T buf = 0;
            buf = info.value;
            *value = &buf;
            *size = 8;
        }
        else {
            static U4_T buf = 0;
            buf = (U4_T)info.value;
            *value = &buf;
            *size = 4;
        }
        *big_endian = big_endian_host();
        return 0;
    }
    errno = ERR_INV_CONTEXT;
    return -1;
}

static int calc_member_offset(ObjectInfo * type, ObjectInfo * member, ContextAddress * offs) {
    PropertyValue v;
    ObjectInfo * obj = NULL;
    if (member->mParent == type) {
        read_and_evaluate_dwarf_object_property(sym_ctx, sym_frame, 0, member, AT_data_member_location, &v);
        *offs = (ContextAddress)get_numeric_property_value(&v);
        return 1;
    }
    obj = type->mChildren;
    while (obj != NULL) {
        if (obj->mTag == TAG_inheritance && calc_member_offset(obj->mType, member, offs)) {
            read_and_evaluate_dwarf_object_property(sym_ctx, sym_frame, 0, obj, AT_data_member_location, &v);
            *offs += (ContextAddress)get_numeric_property_value(&v);
            return 1;
        }
        obj = obj->mSibling;
    }
    return 0;
}

int get_symbol_address(const Symbol * sym, ContextAddress * address) {
    ObjectInfo * obj = sym->obj;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base || is_cardinal_type_pseudo_symbol(sym)) {
        errno = ERR_INV_CONTEXT;
        return -1;
    }
    if (sym->has_address) {
        *address = sym->address;
        return 0;
    }
    if (unpack(sym) < 0) return -1;
    if (sym->var != NULL) {
        /* The symbol represents a member of a class instance */
        Trap trap;
        PropertyValue v;
        ContextAddress base = 0;
        ContextAddress offs = 0;
        ObjectInfo * type = get_original_type(sym->var);
        if (!set_trap(&trap)) return -1;
        if ((type->mTag != TAG_pointer_type && type->mTag != TAG_mod_pointer) || type->mType == NULL) exception(ERR_INV_CONTEXT);
        read_and_evaluate_dwarf_object_property(sym_ctx, sym_frame, 0, sym->var, AT_location, &v);
        if (v.mPieces != NULL) {
            str_exception(ERR_UNSUPPORTED, "Unsupported location of 'this' pointer");
        }
        else if (v.mRegister != NULL) {
            U8_T rv = 0;
            StackFrame * frame = NULL;
            if (get_frame_info(v.mContext, v.mFrame, &frame) < 0) exception(errno);
            if (read_reg_value(frame, v.mRegister, &rv) < 0) exception(errno);
            base = (ContextAddress)rv;
        }
        else {
            if (elf_read_memory_word(sym_ctx, sym->var->mCompUnit->mFile,
                (ContextAddress)get_numeric_property_value(&v), &base) < 0) exception(errno);
        }
        type = get_original_type(type->mType);
        if (!calc_member_offset(type, obj, &offs)) exception(ERR_INV_CONTEXT);
        clear_trap(&trap);
        *address = base + offs;
        return 0;
    }
    if (obj != NULL && obj->mTag != TAG_member && obj->mTag != TAG_inheritance) {
        U8_T v;
        Symbol * s = NULL;
        if (get_num_prop(obj, AT_location, &v)) {
            *address = (ContextAddress)v;
            return 0;
        }
        if (get_error_code(errno) != ERR_SYM_NOT_FOUND) return -1;
        if (get_num_prop(obj, AT_low_pc, &v)) {
            *address = (ContextAddress)v;
            return 0;
        }
        if (get_error_code(errno) != ERR_SYM_NOT_FOUND) return -1;
        if (map_to_sym_table(obj, &s)) return get_symbol_address(s, address);
        set_errno(ERR_OTHER, "No object location info found in DWARF data");
        return -1;
    }
    if (sym->tbl != NULL) {
        ELF_SymbolInfo info;
        unpack_elf_symbol_info(sym->tbl, sym->index, &info);
        return syminfo2address(sym_ctx, &info, address);
    }

    errno = ERR_INV_CONTEXT;
    return -1;
}

int get_symbol_register(const Symbol * sym, Context ** ctx, int * frame, RegisterDefinition ** reg) {
    ObjectInfo * obj = sym->obj;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base || is_cardinal_type_pseudo_symbol(sym) || sym->has_address) {
        errno = ERR_INV_CONTEXT;
        return -1;
    }
    if (unpack(sym) < 0) return -1;
    if (obj != NULL && obj->mTag != TAG_member && obj->mTag != TAG_inheritance) {
        Trap trap;
        if (set_trap(&trap)) {
            PropertyValue v;
            read_and_evaluate_dwarf_object_property(sym_ctx, sym_frame, 0, obj, AT_location, &v);
            *ctx = sym_ctx;
            *frame = sym_frame;
            *reg = v.mRegister;
            clear_trap(&trap);
            return 0;
        }
    }

    errno = ERR_INV_CONTEXT;
    return -1;
}

int get_symbol_flags(const Symbol * sym, SYM_FLAGS * flags) {
    U8_T v = 0;
    ObjectInfo * i = NULL;
    ObjectInfo * obj = sym->obj;
    *flags = 0;
    assert(sym->magic == SYMBOL_MAGIC);
    if (sym->base || is_cardinal_type_pseudo_symbol(sym)) return 0;
    if (unpack(sym) < 0) return -1;
    i = obj;
    while (i != NULL) {
        switch (i->mTag) {
        case TAG_subrange_type:
            *flags |= SYM_FLAG_SUBRANGE_TYPE;
            i = i->mType;
            break;
        case TAG_packed_type:
            *flags |= SYM_FLAG_PACKET_TYPE;
            i = i->mType;
            break;
        case TAG_const_type:
            *flags |= SYM_FLAG_CONST_TYPE;
            i = i->mType;
            break;
        case TAG_volatile_type:
            *flags |= SYM_FLAG_VOLATILE_TYPE;
            i = i->mType;
            break;
        case TAG_restrict_type:
            *flags |= SYM_FLAG_RESTRICT_TYPE;
            i = i->mType;
            break;
        case TAG_shared_type:
            *flags |= SYM_FLAG_SHARED_TYPE;
            i = i->mType;
            break;
        case TAG_typedef:
            if (i == obj) *flags |= SYM_FLAG_TYPEDEF;
            i = i->mType;
            break;
        case TAG_reference_type:
        case TAG_mod_reference:
            *flags |= SYM_FLAG_REFERENCE;
            i = NULL;
            break;
        case TAG_union_type:
            *flags |= SYM_FLAG_UNION_TYPE;
            i = NULL;
            break;
        case TAG_class_type:
            *flags |= SYM_FLAG_CLASS_TYPE;
            i = NULL;
            break;
        case TAG_interface_type:
            *flags |= SYM_FLAG_INTERFACE_TYPE;
            i = NULL;
            break;
        case TAG_unspecified_parameters:
            *flags |= SYM_FLAG_PARAMETER;
            *flags |= SYM_FLAG_VARARG;
            i = NULL;
            break;
        case TAG_formal_parameter:
        case TAG_variable:
        case TAG_constant:
        case TAG_base_type:
            if (i->mTag == TAG_formal_parameter) {
                *flags |= SYM_FLAG_PARAMETER;
                if (get_num_prop(i, AT_is_optional, &v) && v != 0) *flags |= SYM_FLAG_OPTIONAL;
            }
            if (i->mTag == TAG_variable && get_num_prop(obj, AT_external, &v) && v != 0) {
                *flags |= SYM_FLAG_EXTERNAL;
            }
            if (get_num_prop(i, AT_endianity, &v)) {
                if (v == DW_END_big) *flags |= SYM_FLAG_BIG_ENDIAN;
                if (v == DW_END_little) *flags |= SYM_FLAG_LITTLE_ENDIAN;
            }
            i = NULL;
            break;
        default:
            i = NULL;
            break;
        }
    }
    if (obj != NULL && sym->sym_class == SYM_CLASS_TYPE && !(*flags & (SYM_FLAG_BIG_ENDIAN|SYM_FLAG_LITTLE_ENDIAN))) {
        *flags |= obj->mCompUnit->mFile->big_endian ? SYM_FLAG_BIG_ENDIAN : SYM_FLAG_LITTLE_ENDIAN;
    }
    return 0;
}

int get_array_symbol(const Symbol * sym, ContextAddress length, Symbol ** ptr) {
    assert(sym->magic == SYMBOL_MAGIC);
    assert(sym->sym_class == SYM_CLASS_TYPE);
    assert(sym->frame == STACK_NO_FRAME);
    assert(sym->ctx == context_get_group(sym->ctx, CONTEXT_GROUP_PROCESS));
    *ptr = alloc_symbol();
    (*ptr)->ctx = sym->ctx;
    (*ptr)->frame = STACK_NO_FRAME;
    (*ptr)->sym_class = SYM_CLASS_TYPE;
    (*ptr)->base = (Symbol *)sym;
    (*ptr)->length = length;
    return 0;
}

#endif /* SERVICE_Symbols && ENABLE_ELF */