vbagx/source/vba/elf.cpp

// VisualBoyAdvance - Nintendo Gameboy/GameboyAdvance (TM) emulator.
// Copyright (C) 1999-2003 Forgotten
// Copyright (C) 2004 Forgotten and the VBA development team

// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2, or(at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software Foundation,
// Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

#include "sdfileio.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "GBA.h"
#include "Port.h"
#include "elf.h"
#include "NLS.h"

#define elfReadMemory(addr) \
  READ32LE((&map[(addr)>>24].address[(addr) & map[(addr)>>24].mask]))

#define DW_TAG_array_type             0x01
#define DW_TAG_enumeration_type       0x04
#define DW_TAG_formal_parameter       0x05
#define DW_TAG_label                  0x0a
#define DW_TAG_lexical_block          0x0b
#define DW_TAG_member                 0x0d
#define DW_TAG_pointer_type           0x0f
#define DW_TAG_reference_type         0x10
#define DW_TAG_compile_unit           0x11
#define DW_TAG_structure_type         0x13
#define DW_TAG_subroutine_type        0x15
#define DW_TAG_typedef                0x16
#define DW_TAG_union_type             0x17
#define DW_TAG_unspecified_parameters 0x18
#define DW_TAG_inheritance            0x1c
#define DW_TAG_inlined_subroutine     0x1d
#define DW_TAG_subrange_type          0x21
#define DW_TAG_base_type              0x24
#define DW_TAG_const_type             0x26
#define DW_TAG_enumerator             0x28
#define DW_TAG_subprogram             0x2e
#define DW_TAG_variable               0x34
#define DW_TAG_volatile_type          0x35

#define DW_AT_sibling              0x01
#define DW_AT_location             0x02
#define DW_AT_name                 0x03
#define DW_AT_byte_size            0x0b
#define DW_AT_bit_offset           0x0c
#define DW_AT_bit_size             0x0d
#define DW_AT_stmt_list            0x10
#define DW_AT_low_pc               0x11
#define DW_AT_high_pc              0x12
#define DW_AT_language             0x13
#define DW_AT_compdir              0x1b
#define DW_AT_const_value          0x1c
#define DW_AT_containing_type      0x1d
#define DW_AT_inline               0x20
#define DW_AT_producer             0x25
#define DW_AT_prototyped           0x27
#define DW_AT_upper_bound          0x2f
#define DW_AT_abstract_origin      0x31
#define DW_AT_accessibility        0x32
#define DW_AT_artificial           0x34
#define DW_AT_data_member_location 0x38
#define DW_AT_decl_file            0x3a
#define DW_AT_decl_line            0x3b
#define DW_AT_declaration          0x3c
#define DW_AT_encoding             0x3e
#define DW_AT_external             0x3f
#define DW_AT_frame_base           0x40
#define DW_AT_macro_info           0x43
#define DW_AT_specification        0x47
#define DW_AT_type                 0x49
#define DW_AT_virtuality           0x4c
#define DW_AT_vtable_elem_location 0x4d
// DWARF 2.1/3.0 extensions
#define DW_AT_entry_pc             0x52
#define DW_AT_ranges               0x55
// ARM Compiler extensions
#define DW_AT_proc_body            0x2000
#define DW_AT_save_offset          0x2001
#define DW_AT_user_2002            0x2002
// MIPS extensions
#define DW_AT_MIPS_linkage_name    0x2007

#define DW_FORM_addr      0x01
#define DW_FORM_data2     0x05
#define DW_FORM_data4     0x06
#define DW_FORM_string    0x08
#define DW_FORM_block     0x09
#define DW_FORM_block1    0x0a
#define DW_FORM_data1     0x0b
#define DW_FORM_flag      0x0c
#define DW_FORM_sdata     0x0d
#define DW_FORM_strp      0x0e
#define DW_FORM_udata     0x0f
#define DW_FORM_ref_addr  0x10
#define DW_FORM_ref4      0x13
#define DW_FORM_ref_udata 0x15
#define DW_FORM_indirect  0x16

#define DW_OP_addr        0x03
#define DW_OP_plus_uconst 0x23
#define DW_OP_reg0        0x50
#define DW_OP_reg1        0x51
#define DW_OP_reg2        0x52
#define DW_OP_reg3        0x53
#define DW_OP_reg4        0x54
#define DW_OP_reg5        0x55
#define DW_OP_reg6        0x56
#define DW_OP_reg7        0x57
#define DW_OP_reg8        0x58
#define DW_OP_reg9        0x59
#define DW_OP_reg10       0x5a
#define DW_OP_reg11       0x5b
#define DW_OP_reg12       0x5c
#define DW_OP_reg13       0x5d
#define DW_OP_reg14       0x5e
#define DW_OP_reg15       0x5f
#define DW_OP_fbreg       0x91

#define DW_LNS_extended_op      0x00
#define DW_LNS_copy             0x01
#define DW_LNS_advance_pc       0x02
#define DW_LNS_advance_line     0x03
#define DW_LNS_set_file         0x04
#define DW_LNS_set_column       0x05
#define DW_LNS_negate_stmt      0x06
#define DW_LNS_set_basic_block  0x07
#define DW_LNS_const_add_pc     0x08
#define DW_LNS_fixed_advance_pc 0x09

#define DW_LNE_end_sequence 0x01
#define DW_LNE_set_address  0x02
#define DW_LNE_define_file  0x03

#define DW_CFA_advance_loc      0x01
#define DW_CFA_offset           0x02
#define DW_CFA_restore          0x03
#define DW_CFA_set_loc          0x01
#define DW_CFA_advance_loc1     0x02
#define DW_CFA_advance_loc2     0x03
#define DW_CFA_advance_loc4     0x04
#define DW_CFA_offset_extended  0x05
#define DW_CFA_restore_extended 0x06
#define DW_CFA_undefined        0x07
#define DW_CFA_same_value       0x08
#define DW_CFA_register         0x09
#define DW_CFA_remember_state   0x0a
#define DW_CFA_restore_state    0x0b
#define DW_CFA_def_cfa          0x0c
#define DW_CFA_def_cfa_register 0x0d
#define DW_CFA_def_cfa_offset   0x0e
#define DW_CFA_nop              0x00

#define CASE_TYPE_TAG \
    case DW_TAG_const_type:\
    case DW_TAG_volatile_type:\
    case DW_TAG_pointer_type:\
    case DW_TAG_base_type:\
    case DW_TAG_array_type:\
    case DW_TAG_structure_type:\
    case DW_TAG_union_type:\
    case DW_TAG_typedef:\
    case DW_TAG_subroutine_type:\
    case DW_TAG_enumeration_type:\
    case DW_TAG_enumerator:\
    case DW_TAG_reference_type

struct ELFcie
  {
    ELFcie *next;
    u32 offset;
    u8 *augmentation;
    u32 codeAlign;
    s32 dataAlign;
    int returnAddress;
    u8 *data;
    u32 dataLen;
  };

struct ELFfde
  {
    ELFcie *cie;
    u32 address;
    u32 end;
    u8 *data;
    u32 dataLen;
  };

enum ELFRegMode {
  REG_NOT_SET,
  REG_OFFSET,
  REG_REGISTER
};


struct ELFFrameStateRegister
  {
    ELFRegMode mode;
    int reg;
    s32 offset;
  };

struct ELFFrameStateRegisters
  {
    ELFFrameStateRegister regs[16];
    ELFFrameStateRegisters *previous;
  };

enum ELFCfaMode {
  CFA_NOT_SET,
  CFA_REG_OFFSET
};

struct ELFFrameState
  {
    ELFFrameStateRegisters registers;

    ELFCfaMode cfaMode;
    int cfaRegister;
    s32 cfaOffset;

    u32 pc;

    int dataAlign;
    int codeAlign;
    int returnAddress;
  };

extern bool cpuIsMultiBoot;

Symbol *elfSymbols = NULL;
char *elfSymbolsStrTab = NULL;
int elfSymbolsCount = 0;

ELFSectionHeader **elfSectionHeaders = NULL;
char *elfSectionHeadersStringTable = NULL;
int elfSectionHeadersCount = 0;
u8 *elfFileData = NULL;

CompileUnit *elfCompileUnits = NULL;
DebugInfo *elfDebugInfo = NULL;
char *elfDebugStrings = NULL;

ELFcie *elfCies = NULL;
ELFfde **elfFdes = NULL;
int elfFdeCount = 0;

CompileUnit *elfCurrentUnit = NULL;

u32 elfRead4Bytes(u8 *);
u16 elfRead2Bytes(u8 *);

CompileUnit *elfGetCompileUnit(u32 addr)
{
  if(elfCompileUnits)
    {
      CompileUnit *unit = elfCompileUnits;
      while(unit)
        {
          if(unit->lowPC)
            {
              if(addr >= unit->lowPC && addr < unit->highPC)
                return unit;
            }
          else
            {
              ARanges *r = unit->ranges;
              if(r)
                {
                  int count = r->count;
                  for(int j = 0; j < count; j++)
                    {
                      if(addr >= r->ranges[j].lowPC && addr < r->ranges[j].highPC)
                        return unit;
                    }
                }
            }
          unit = unit->next;
        }
    }
  return NULL;
}

char *elfGetAddressSymbol(u32 addr)
{
  static char buffer[256];

  CompileUnit *unit = elfGetCompileUnit(addr);
  // found unit, need to find function
  if(unit)
    {
      Function *func = unit->functions;
      while(func)
        {
          if(addr >= func->lowPC && addr < func->highPC)
            {
              int offset = addr - func->lowPC;
              char *name = func->name;
              if(!name)
                name = "";
              if(offset)
                sprintf(buffer, "%s+%d", name, offset);
              else
                strcpy(buffer, name);
              return buffer;
            }
          func = func->next;
        }
    }

  if(elfSymbolsCount)
    {
      for(int i = 0; i < elfSymbolsCount; i++)
        {
          Symbol *s = &elfSymbols[i];
          if((addr >= s->value)  && addr < (s->value+s->size))
            {
              int offset = addr-s->value;
              char *name = s->name;
              if(name == NULL)
                name = "";
              if(offset)
                sprintf(buffer, "%s+%d", name, addr-s->value);
              else
                strcpy(buffer, name);
              return buffer;
            }
          else if(addr == s->value)
            {
              if(s->name)
                strcpy(buffer, s->name);
              else
                strcpy(buffer, "");
              return buffer;
            }
        }
    }

  return "";
}

bool elfFindLineInModule(u32 *addr, char *name, int line)
{
  CompileUnit *unit = elfCompileUnits;

  while(unit)
    {
      if(unit->lineInfoTable)
        {
          int i;
          int count = unit->lineInfoTable->fileCount;
          char *found = NULL;
          for(i = 0; i < count; i++)
            {
              if(strcmp(name, unit->lineInfoTable->files[i]) == 0)
                {
                  found = unit->lineInfoTable->files[i];
                  break;
                }
            }
          // found a matching filename... try to find line now
          if(found)
            {
              LineInfoItem *table = unit->lineInfoTable->lines;
              count = unit->lineInfoTable->number;
              for(i = 0; i < count; i++)
                {
                  if(table[i].file == found && table[i].line == line)
                    {
                      *addr = table[i].address;
                      return true;
                    }
                }
              // we can only find a single match
              return false;
            }
        }
      unit = unit->next;
    }
  return false;
}

int elfFindLine(CompileUnit *unit, Function * /* func */, u32 addr, char **f)
{
  int currentLine = -1;
  if(unit->hasLineInfo)
    {
      int count = unit->lineInfoTable->number;
      LineInfoItem *table = unit->lineInfoTable->lines;
      int i;
      for(i = 0; i < count; i++)
        {
          if(addr <= table[i].address)
            break;
        }
      if(i == count)
        i--;
      *f = table[i].file;
      currentLine = table[i].line;
    }
  return currentLine;
}

bool elfFindLineInUnit(u32 *addr, CompileUnit *unit, int line)
{
  if(unit->hasLineInfo)
    {
      int count = unit->lineInfoTable->number;
      LineInfoItem *table = unit->lineInfoTable->lines;
      int i;
      for(i = 0; i < count; i++)
        {
          if(line == table[i].line)
            {
              *addr = table[i].address;
              return true;
            }
        }
    }
  return false;
}

bool elfGetCurrentFunction(u32 addr, Function **f, CompileUnit **u)
{
  CompileUnit *unit = elfGetCompileUnit(addr);
  // found unit, need to find function
  if(unit)
    {
      Function *func = unit->functions;
      while(func)
        {
          if(addr >= func->lowPC && addr < func->highPC)
            {
              *f = func;
              *u = unit;
              return true;
            }
          func = func->next;
        }
    }
  return false;
}

bool elfGetObject(char *name, Function *f, CompileUnit *u, Object **o)
{
  if(f && u)
    {
      Object *v = f->variables;

      while(v)
        {
          if(strcmp(name, v->name) == 0)
            {
              *o = v;
              return true;
            }
          v = v->next;
        }
      v = f->parameters;
      while(v)
        {
          if(strcmp(name, v->name) == 0)
            {
              *o = v;
              return true;
            }
          v = v->next;
        }
      v = u->variables;
      while(v)
        {
          if(strcmp(name, v->name) == 0)
            {
              *o = v;
              return true;
            }
          v = v->next;
        }
    }

  CompileUnit *c = elfCompileUnits;

  while(c)
    {
      if(c != u)
        {
          Object *v = c->variables;
          while(v)
            {
              if(strcmp(name, v->name) == 0)
                {
                  *o = v;
                  return true;
                }
              v = v->next;
            }
        }
      c = c->next;
    }

  return false;
}

char *elfGetSymbol(int i, u32 *value, u32 *size, int *type)
{
  if(i < elfSymbolsCount)
    {
      Symbol *s = &elfSymbols[i];
      *value = s->value;
      *size = s->size;
      *type = s->type;
      return s->name;
    }
  return NULL;
}

bool elfGetSymbolAddress(char *sym, u32 *addr, u32 *size, int *type)
{
  if(elfSymbolsCount)
    {
      for(int i = 0; i < elfSymbolsCount; i++)
        {
          Symbol *s = &elfSymbols[i];
          if(strcmp(sym, s->name) == 0)
            {
              *addr = s->value;
              *size = s->size;
              *type = s->type;
              return true;
            }
        }
    }
  return false;
}

ELFfde *elfGetFde(u32 address)
{
  if(elfFdes)
    {
      int i;
      for(i = 0; i < elfFdeCount; i++)
        {
          if(address >= elfFdes[i]->address &&
              address < elfFdes[i]->end)
            {
              return elfFdes[i];
            }
        }
    }

  return NULL;
}

void elfExecuteCFAInstructions(ELFFrameState *state, u8 *data, u32 len,
                               u32 pc)
{
  u8 *end = data + len;
  int bytes;
  int reg;
  ELFFrameStateRegisters *fs;

  while(data < end && state->pc < pc)
    {
      u8 op = *data++;

      switch(op >> 6)
        {
        case DW_CFA_advance_loc:
          state->pc += (op & 0x3f) * state->codeAlign;
          break;
        case DW_CFA_offset:
          reg = op & 0x3f;
          state->registers.regs[reg].mode = REG_OFFSET;
          state->registers.regs[reg].offset = state->dataAlign *
                                              (s32)elfReadLEB128(data, &bytes);
          data += bytes;
          break;
        case DW_CFA_restore:
          // we don't care much about the other possible settings,
          // so just setting to unset is enough for now
          state->registers.regs[op & 0x3f].mode = REG_NOT_SET;
          break;
        case 0:
          switch(op & 0x3f)
            {
            case DW_CFA_nop:
              break;
            case DW_CFA_advance_loc1:
              state->pc += state->codeAlign * (*data++);
              break;
            case DW_CFA_advance_loc2:
              state->pc += state->codeAlign * elfRead2Bytes(data);
              data += 2;
              break;
            case DW_CFA_advance_loc4:
              state->pc += state->codeAlign * elfRead4Bytes(data);
              data += 4;
              break;
            case DW_CFA_offset_extended:
              reg = elfReadLEB128(data, &bytes);
              data += bytes;
              state->registers.regs[reg].mode = REG_OFFSET;
              state->registers.regs[reg].offset = state->dataAlign *
                                                  (s32)elfReadLEB128(data, &bytes);
              data += bytes;
              break;
            case DW_CFA_restore_extended:
            case DW_CFA_undefined:
            case DW_CFA_same_value:
              reg = elfReadLEB128(data, &bytes);
              data += bytes;
              state->registers.regs[reg].mode = REG_NOT_SET;
              break;
            case DW_CFA_register:
              reg = elfReadLEB128(data, &bytes);
              data += bytes;
              state->registers.regs[reg].mode = REG_REGISTER;
              state->registers.regs[reg].reg = elfReadLEB128(data, &bytes);
              data += bytes;
              break;
            case DW_CFA_remember_state:
              fs = (ELFFrameStateRegisters *)calloc(1,
                                                    sizeof(ELFFrameStateRegisters));
              memcpy(fs, &state->registers, sizeof(ELFFrameStateRegisters));
              state->registers.previous = fs;
              break;
            case DW_CFA_restore_state:
              if(state->registers.previous == NULL)
                {
                  printf("Error: previous frame state is NULL.\n");
                  return;
                }
              fs = state->registers.previous;
              memcpy(&state->registers, fs, sizeof(ELFFrameStateRegisters));
              free(fs);
              break;
            case DW_CFA_def_cfa:
              state->cfaRegister = elfReadLEB128(data, &bytes);
              data += bytes;
              state->cfaOffset = (s32)elfReadLEB128(data, &bytes);
              data += bytes;
              state->cfaMode = CFA_REG_OFFSET;
              break;
            case DW_CFA_def_cfa_register:
              state->cfaRegister = elfReadLEB128(data, &bytes);
              data += bytes;
              state->cfaMode = CFA_REG_OFFSET;
              break;
            case DW_CFA_def_cfa_offset:
              state->cfaOffset = (s32)elfReadLEB128(data, &bytes);
              data += bytes;
              state->cfaMode = CFA_REG_OFFSET;
              break;
            default:
              printf("Unknown CFA opcode %08x\n", op);
              return;
            }
          break;
        default:
          printf("Unknown CFA opcode %08x\n", op);
          return;
        }
    }
}

ELFFrameState *elfGetFrameState(ELFfde *fde, u32 address)
{
  ELFFrameState *state = (ELFFrameState *)calloc(1, sizeof(ELFFrameState));
  state->pc = fde->address;
  state->dataAlign = fde->cie->dataAlign;
  state->codeAlign = fde->cie->codeAlign;
  state->returnAddress = fde->cie->returnAddress;

  elfExecuteCFAInstructions(state,
                            fde->cie->data,
                            fde->cie->dataLen,
                            0xffffffff);
  elfExecuteCFAInstructions(state,
                            fde->data,
                            fde->dataLen,
                            address);

  return state;
}

void elfPrintCallChain(u32 address)
{
  int count = 1;

  reg_pair regs[15];
  reg_pair newRegs[15];

  memcpy(&regs[0], &reg[0], sizeof(reg_pair) * 15);

  while(count < 20)
    {
      char *addr = elfGetAddressSymbol(address);
      if(*addr == 0)
        addr = "???";

      printf("%08x %s\n", address, addr);

      ELFfde *fde = elfGetFde(address);

      if(fde == NULL)
        {
          break;
        }

      ELFFrameState *state = elfGetFrameState(fde, address);

      if(!state)
        {
          break;
        }

      if(state->cfaMode == CFA_REG_OFFSET)
        {
          memcpy(&newRegs[0], &regs[0], sizeof(reg_pair) * 15);
          u32 addr = 0;
          for(int i = 0; i < 15; i++)
            {
              ELFFrameStateRegister *r = &state->registers.
                                         regs[i];

              switch(r->mode)
                {
                case REG_NOT_SET:
                  newRegs[i].I = regs[i].I;
                  break;
                case REG_OFFSET:
                  newRegs[i].I = elfReadMemory(regs[state->cfaRegister].I +
                                               state->cfaOffset +
                                               r->offset);
                  break;
                case REG_REGISTER:
                  newRegs[i].I = regs[r->reg].I;
                  break;
                default:
                  printf("Unknown register mode: %d\n", r->mode);
                  break;
                }
            }
          memcpy(regs, newRegs, sizeof(reg_pair)*15);
          addr = newRegs[14].I;
          addr &= 0xfffffffe;
          address = addr;
          count++;
        }
      else
        {
          printf("CFA not set\n");
          break;
        }
      if(state->registers.previous)
        {
          ELFFrameStateRegisters *prev = state->registers.previous;

          while(prev)
            {
              ELFFrameStateRegisters *p = prev->previous;
              free(prev);
              prev = p;
            }
        }
      free(state);
    }
}

u32 elfDecodeLocation(Function *f, ELFBlock *o, LocationType *type, u32 base)
{
  u32 framebase = 0;
  if(f && f->frameBase)
    {
      ELFBlock *b = f->frameBase;
      switch(*b->data)
        {
        case DW_OP_reg0:
        case DW_OP_reg1:
        case DW_OP_reg2:
        case DW_OP_reg3:
        case DW_OP_reg4:
        case DW_OP_reg5:
        case DW_OP_reg6:
        case DW_OP_reg7:
        case DW_OP_reg8:
        case DW_OP_reg9:
        case DW_OP_reg10:
        case DW_OP_reg11:
        case DW_OP_reg12:
        case DW_OP_reg13:
        case DW_OP_reg14:
        case DW_OP_reg15:
          framebase = reg[*b->data-0x50].I;
          break;
        default:
          fprintf(stderr, "Unknown frameBase %02x\n", *b->data);
          break;
        }
    }

  ELFBlock *loc = o;
  u32 location = 0;
  int bytes = 0;
  if(loc)
    {
      switch(*loc->data)
        {
        case DW_OP_addr:
          location = elfRead4Bytes(loc->data+1);
          *type = LOCATION_memory;
          break;
        case DW_OP_plus_uconst:
          location = base + elfReadLEB128(loc->data+1, &bytes);
          *type = LOCATION_memory;
          break;
        case DW_OP_reg0:
        case DW_OP_reg1:
        case DW_OP_reg2:
        case DW_OP_reg3:
        case DW_OP_reg4:
        case DW_OP_reg5:
        case DW_OP_reg6:
        case DW_OP_reg7:
        case DW_OP_reg8:
        case DW_OP_reg9:
        case DW_OP_reg10:
        case DW_OP_reg11:
        case DW_OP_reg12:
        case DW_OP_reg13:
        case DW_OP_reg14:
        case DW_OP_reg15:
          location = *loc->data - 0x50;
          *type = LOCATION_register;
          break;
        case DW_OP_fbreg:
        {
          int bytes;
          s32 off = elfReadSignedLEB128(loc->data+1, &bytes);
          location = framebase + off;
          *type = LOCATION_memory;
        }
        break;
        default:
          fprintf(stderr, "Unknown location %02x\n", *loc->data);
          break;
        }
    }
  return location;
}

u32 elfDecodeLocation(Function *f, ELFBlock *o, LocationType *type)
{
  return elfDecodeLocation(f, o, type, 0);
}

// reading function

u32 elfRead4Bytes(u8 *data)
{
  u32 value = *data++;
  value |= (*data++ << 8);
  value |= (*data++ << 16);
  value |= (*data << 24);
  return value;
}

u16 elfRead2Bytes(u8 *data)
{
  u16 value = *data++;
  value |= (*data << 8);
  return value;
}

char *elfReadString(u8 *data, int *bytesRead)
{
  if(*data == 0)
    {
      *bytesRead = 1;
      return NULL;
    }
  *bytesRead = strlen((char *)data) + 1;
  return (char *)data;
}

s32 elfReadSignedLEB128(u8 *data, int *bytesRead)
{
  s32 result = 0;
  int shift = 0;
  int count = 0;

  u8 byte;
  do
    {
      byte = *data++;
      count++;
      result |= (byte & 0x7f) << shift;
      shift += 7;
    }
  while(byte & 0x80);
  if((shift < 32) && (byte & 0x40))
    result |= -(1 << shift);
  *bytesRead = count;
  return result;
}

u32 elfReadLEB128(u8 *data, int *bytesRead)
{
  u32 result = 0;
  int shift = 0;
  int count = 0;
  u8 byte;
  do
    {
      byte = *data++;
      count++;
      result |= (byte & 0x7f) << shift;
      shift += 7;
    }
  while(byte & 0x80);
  *bytesRead = count;
  return result;
}

u8 *elfReadSection(u8 *data, ELFSectionHeader *sh)
{
  return data + READ32LE(&sh->offset);
}

ELFSectionHeader *elfGetSectionByName(char *name)
{
  for(int i = 0; i < elfSectionHeadersCount; i++)
    {
      if(strcmp(name,
                &elfSectionHeadersStringTable[READ32LE(&elfSectionHeaders[i]->
                                                       name)]) == 0)
        {
          return elfSectionHeaders[i];
        }
    }
  return NULL;
}

ELFSectionHeader *elfGetSectionByNumber(int number)
{
  if(number < elfSectionHeadersCount)
    {
      return elfSectionHeaders[number];
    }
  return NULL;
}

CompileUnit *elfGetCompileUnitForData(u8 *data)
{
  u8 *end = elfCurrentUnit->top + 4 + elfCurrentUnit->length;

  if(data >= elfCurrentUnit->top && data < end)
    return elfCurrentUnit;

  CompileUnit *unit = elfCompileUnits;

  while(unit)
    {
      end = unit->top + 4 + unit->length;

      if(data >= unit->top && data < end)
        return unit;

      unit = unit->next;
    }

  printf("Error: cannot find reference to compile unit at offset %08x\n",
         (int)(data - elfDebugInfo->infodata));
  exit(-1);
}

u8 *elfReadAttribute(u8 *data, ELFAttr *attr)
{
  int bytes;
  int form = attr->form;
start:
  switch(form)
    {
    case DW_FORM_addr:
      attr->value = elfRead4Bytes(data);
      data += 4;
      break;
    case DW_FORM_data2:
      attr->value = elfRead2Bytes(data);
      data += 2;
      break;
    case DW_FORM_data4:
      attr->value = elfRead4Bytes(data);
      data += 4;
      break;
    case DW_FORM_string:
      attr->string = (char *)data;
      data += strlen(attr->string)+1;
      break;
    case DW_FORM_strp:
      attr->string = elfDebugStrings + elfRead4Bytes(data);
      data += 4;
      break;
    case DW_FORM_block:
      attr->block = (ELFBlock *)malloc(sizeof(ELFBlock));
      attr->block->length = elfReadLEB128(data, &bytes);
      data += bytes;
      attr->block->data = data;
      data += attr->block->length;
      break;
    case DW_FORM_block1:
      attr->block = (ELFBlock *)malloc(sizeof(ELFBlock));
      attr->block->length = *data++;
      attr->block->data = data;
      data += attr->block->length;
      break;
    case DW_FORM_data1:
      attr->value = *data++;
      break;
    case DW_FORM_flag:
      attr->flag = (*data++) ? true : false;
      break;
    case DW_FORM_sdata:
      attr->value = elfReadSignedLEB128(data, &bytes);
      data += bytes;
      break;
    case DW_FORM_udata:
      attr->value = elfReadLEB128(data, &bytes);
      data += bytes;
      break;
    case DW_FORM_ref_addr:
      attr->value = (elfDebugInfo->infodata + elfRead4Bytes(data)) -
                    elfGetCompileUnitForData(data)->top;
      data += 4;
      break;
    case DW_FORM_ref4:
      attr->value = elfRead4Bytes(data);
      data += 4;
      break;
    case DW_FORM_ref_udata:
      attr->value = (elfDebugInfo->infodata +
                     (elfGetCompileUnitForData(data)->top -
                      elfDebugInfo->infodata) +
                     elfReadLEB128(data, &bytes)) -
                    elfCurrentUnit->top;
      data += bytes;
      break;
    case DW_FORM_indirect:
      form = elfReadLEB128(data, &bytes);
      data += bytes;
      goto start;
    default:
      fprintf(stderr, "Unsupported FORM %02x\n", form);
      exit(-1);
    }
  return data;
}

ELFAbbrev *elfGetAbbrev(ELFAbbrev **table, u32 number)
{
  int hash = number % 121;

  ELFAbbrev *abbrev = table[hash];

  while(abbrev)
    {
      if(abbrev->number == number)
        return abbrev;
      abbrev = abbrev->next;
    }
  return NULL;
}

ELFAbbrev **elfReadAbbrevs(u8 *data, u32 offset)
{
  data += offset;
  ELFAbbrev **abbrevs = (ELFAbbrev **)calloc(sizeof(ELFAbbrev *)*121,1);
  int bytes = 0;
  u32 number = elfReadLEB128(data, &bytes);
  data += bytes;
  while(number)
    {
      ELFAbbrev *abbrev = (ELFAbbrev *)calloc(sizeof(ELFAbbrev),1);

      // read tag information
      abbrev->number = number;
      abbrev->tag = elfReadLEB128(data, &bytes);
      data += bytes;
      abbrev->hasChildren = *data++ ? true: false;

      // read attributes
      int name = elfReadLEB128(data, &bytes);
      data += bytes;
      int form = elfReadLEB128(data, &bytes);
      data += bytes;

      while(name)
        {
          if((abbrev->numAttrs % 4) == 0)
            {
              abbrev->attrs = (ELFAttr *)realloc(abbrev->attrs,
                                                 (abbrev->numAttrs + 4) *
                                                 sizeof(ELFAttr));
            }
          abbrev->attrs[abbrev->numAttrs].name = name;
          abbrev->attrs[abbrev->numAttrs++].form = form;

          name = elfReadLEB128(data, &bytes);
          data += bytes;
          form = elfReadLEB128(data, &bytes);
          data += bytes;
        }

      int hash = number % 121;
      abbrev->next = abbrevs[hash];
      abbrevs[hash] = abbrev;

      number = elfReadLEB128(data, &bytes);
      data += bytes;

      if(elfGetAbbrev(abbrevs, number) != NULL)
        break;
    }

  return abbrevs;
}

void elfParseCFA(u8 *top)
{
  ELFSectionHeader *h = elfGetSectionByName(".debug_frame");

  if(h == NULL)
    {
      return;
    }

  u8 *data = elfReadSection(top, h);

  u8 *topOffset = data;

  u8 *end = data + READ32LE(&h->size);

  ELFcie *cies = NULL;

  while(data < end)
    {
      u32 offset = data - topOffset;
      u32 len = elfRead4Bytes(data);
      data += 4;

      u8 *dataEnd = data + len;

      u32 id = elfRead4Bytes(data);
      data += 4;

      if(id == 0xffffffff)
        {
          // skip version
          *data++;

          ELFcie *cie = (ELFcie *)calloc(1, sizeof(ELFcie));

          cie->next = cies;
          cies = cie;

          cie->offset = offset;

          cie->augmentation = data;
          while(*data)
            data++;
          data++;

          if(*cie->augmentation)
            {
              fprintf(stderr, "Error: augmentation not supported\n");
              exit(-1);
            }

          int bytes;
          cie->codeAlign = elfReadLEB128(data, &bytes);
          data += bytes;

          cie->dataAlign = elfReadSignedLEB128(data, &bytes);
          data += bytes;

          cie->returnAddress = *data++;

          cie->data = data;
          cie->dataLen = dataEnd - data;
        }
      else
        {
          ELFfde *fde = (ELFfde *)calloc(1, sizeof(ELFfde));

          ELFcie *cie = cies;

          while(cie != NULL)
            {
              if(cie->offset == id)
                break;
              cie = cie->next;
            }

          if(!cie)
            {
              fprintf(stderr, "Cannot find CIE %08x\n", id);
              exit(-1);
            }

          fde->cie = cie;

          fde->address = elfRead4Bytes(data);
          data += 4;

          fde->end = fde->address + elfRead4Bytes(data);
          data += 4;

          fde->data = data;
          fde->dataLen = dataEnd - data;

          if((elfFdeCount %10) == 0)
            {
              elfFdes = (ELFfde **)realloc(elfFdes, (elfFdeCount+10) *
                                           sizeof(ELFfde *));
            }
          elfFdes[elfFdeCount++] = fde;
        }
      data = dataEnd;
    }

  elfCies = cies;
}

void elfAddLine(LineInfo *l, u32 a, int file, int line, int *max)
{
  if(l->number == *max)
    {
      *max += 1000;
      l->lines = (LineInfoItem *)realloc(l->lines, *max*sizeof(LineInfoItem));
    }
  LineInfoItem *li = &l->lines[l->number];
  li->file = l->files[file-1];
  li->address = a;
  li->line = line;
  l->number++;
}

void elfParseLineInfo(CompileUnit *unit, u8 *top)
{
  ELFSectionHeader *h = elfGetSectionByName(".debug_line");
  if(h == NULL)
    {
      fprintf(stderr, "No line information found\n");
      return;
    }
  LineInfo *l = unit->lineInfoTable = (LineInfo *)calloc(1, sizeof(LineInfo));
  l->number = 0;
  int max = 1000;
  l->lines = (LineInfoItem *)malloc(1000*sizeof(LineInfoItem));

  u8 *data = elfReadSection(top, h);
  data += unit->lineInfo;
  u32 totalLen = elfRead4Bytes(data);
  data += 4;
  u8 *end = data + totalLen;
  //  u16 version = elfRead2Bytes(data);
  data += 2;
  //  u32 offset = elfRead4Bytes(data);
  data += 4;
  int minInstrSize = *data++;
  int defaultIsStmt = *data++;
  int lineBase = (s8)*data++;
  int lineRange = *data++;
  int opcodeBase = *data++;
  u8 *stdOpLen = (u8 *)malloc(opcodeBase * sizeof(u8));
  stdOpLen[0] = 1;
  int i;
  for(i = 1; i < opcodeBase; i++)
    stdOpLen[i] = *data++;

  free(stdOpLen);// todo
  int bytes = 0;

  char *s;
  while((s = elfReadString(data, &bytes)) != NULL)
    {
      data += bytes;
      //    fprintf(stderr, "Directory is %s\n", s);
    }
  data += bytes;
  int count = 4;
  int index = 0;
  l->files = (char **)malloc(sizeof(char *)*count);

  while((s = elfReadString(data, &bytes)) != NULL)
    {
      l->files[index++] = s;

      data += bytes;
      // directory
      elfReadLEB128(data, &bytes);
      data += bytes;
      // time
      elfReadLEB128(data, &bytes);
      data += bytes;
      // size
      elfReadLEB128(data, &bytes);
      data += bytes;
      //    fprintf(stderr, "File is %s\n", s);
      if(index == count)
        {
          count += 4;
          l->files = (char **)realloc(l->files, sizeof(char *)*count);
        }
    }
  l->fileCount = index;
  data += bytes;

  while(data < end)
    {
      u32 address = 0;
      int file = 1;
      int line = 1;
      int col = 0;
      int isStmt = defaultIsStmt;
      int basicBlock = 0;
      int endSeq = 0;

      while(!endSeq)
        {
          int op = *data++;
          switch(op)
            {
            case DW_LNS_extended_op:
            {
              data++;
              op = *data++;
              switch(op)
                {
                case DW_LNE_end_sequence:
                  endSeq = 1;
                  break;
                case DW_LNE_set_address:
                  address = elfRead4Bytes(data);
                  data += 4;
                  break;
                default:
                  fprintf(stderr, "Unknown extended LINE opcode %02x\n", op);
                  exit(-1);
                }
            }
            break;
            case DW_LNS_copy:
              //      fprintf(stderr, "Address %08x line %d (%d)\n", address, line, file);
              elfAddLine(l, address, file, line, &max);
              basicBlock = 0;
              break;
            case DW_LNS_advance_pc:
              address += minInstrSize * elfReadLEB128(data, &bytes);
              data += bytes;
              break;
            case DW_LNS_advance_line:
              line += elfReadSignedLEB128(data, &bytes);
              data += bytes;
              break;
            case DW_LNS_set_file:
              file = elfReadLEB128(data, &bytes);
              data += bytes;
              break;
            case DW_LNS_set_column:
              col = elfReadLEB128(data, &bytes);
              data += bytes;
              break;
            case DW_LNS_negate_stmt:
              isStmt = !isStmt;
              break;
            case DW_LNS_set_basic_block:
              basicBlock = 1;
              break;
            case DW_LNS_const_add_pc:
              address += (minInstrSize *((255 - opcodeBase)/lineRange));
              break;
            case DW_LNS_fixed_advance_pc:
              address += elfRead2Bytes(data);
              data += 2;
              break;
            default:
              op = op - opcodeBase;
              address += (op / lineRange) * minInstrSize;
              line += lineBase + (op % lineRange);
              elfAddLine(l, address, file, line, &max);
              //        fprintf(stderr, "Address %08x line %d (%d)\n", address, line,file);
              basicBlock = 1;
              break;
            }
        }
    }
  l->lines = (LineInfoItem *)realloc(l->lines, l->number*sizeof(LineInfoItem));
}

u8 *elfSkipData(u8 *data, ELFAbbrev *abbrev, ELFAbbrev **abbrevs)
{
  int i;
  int bytes;

  for(i = 0; i < abbrev->numAttrs; i++)
    {
      data = elfReadAttribute(data,  &abbrev->attrs[i]);
      if(abbrev->attrs[i].form == DW_FORM_block1)
        free(abbrev->attrs[i].block);
    }

  if(abbrev->hasChildren)
    {
      int nesting = 1;
      while(nesting)
        {
          u32 abbrevNum = elfReadLEB128(data, &bytes);
          data += bytes;

          if(!abbrevNum)
            {
              nesting--;
              continue;
            }

          abbrev = elfGetAbbrev(abbrevs, abbrevNum);

          for(i = 0; i < abbrev->numAttrs; i++)
            {
              data = elfReadAttribute(data,  &abbrev->attrs[i]);
              if(abbrev->attrs[i].form == DW_FORM_block1)
                free(abbrev->attrs[i].block);
            }

          if(abbrev->hasChildren)
            {
              nesting++;
            }
        }
    }
  return data;
}

Type *elfParseType(CompileUnit *unit, u32);
u8 *elfParseObject(u8 *data, ELFAbbrev *abbrev, CompileUnit *unit,
                   Object **object);
u8 *elfParseFunction(u8 *data, ELFAbbrev *abbrev, CompileUnit *unit,
                     Function **function);
void elfCleanUp(Function *);

void elfAddType(Type *type, CompileUnit *unit, u32 offset)
{
  if(type->next == NULL)
    {
      if(unit->types != type && type->offset == 0)
        {
          type->offset = offset;
          type->next = unit->types;
          unit->types = type;
        }
    }
}

void elfParseType(u8 *data, u32 offset, ELFAbbrev *abbrev, CompileUnit *unit,
                  Type **type)
{
  switch(abbrev->tag)
    {
    case DW_TAG_typedef:
    {
      u32 typeref = 0;
      char *name = NULL;
      for(int i = 0; i < abbrev->numAttrs; i++)
        {
          ELFAttr *attr = &abbrev->attrs[i];
          data = elfReadAttribute(data, attr);
          switch(attr->name)
            {
            case DW_AT_name:
              name = attr->string;
              break;
            case DW_AT_type:
              typeref = attr->value;
              break;
            case DW_AT_decl_file:
            case DW_AT_decl_line:
              break;
            default:
              fprintf(stderr, "Unknown attribute for typedef %02x\n", attr->name);
              break;
            }
        }
      if(abbrev->hasChildren)
        fprintf(stderr, "Unexpected children for typedef\n");
      *type = elfParseType(unit, typeref);
      if(name)
        (*type)->name = name;
      return;
    }
    break;
    case DW_TAG_union_type:
    case DW_TAG_structure_type:
    {
      Type *t = (Type *)calloc(sizeof(Type), 1);
      if(abbrev->tag == DW_TAG_structure_type)
        t->type = TYPE_struct;
      else
        t->type = TYPE_union;

      Struct *s = (Struct *)calloc(sizeof(Struct), 1);
      t->structure = s;
      elfAddType(t, unit, offset);

      for(int i = 0; i < abbrev->numAttrs; i++)
        {
          ELFAttr *attr = &abbrev->attrs[i];
          data = elfReadAttribute(data, attr);
          switch(attr->name)
            {
            case DW_AT_name:
              t->name = attr->string;
              break;
            case DW_AT_byte_size:
              t->size = attr->value;
              break;
            case DW_AT_decl_file:
            case DW_AT_decl_line:
            case DW_AT_sibling:
            case DW_AT_containing_type: // todo?
            case DW_AT_declaration:
            case DW_AT_specification: // TODO:
              break;
            default:
              fprintf(stderr, "Unknown attribute for struct %02x\n", attr->name);
              break;
            }
        }
      if(abbrev->hasChildren)
        {
          int bytes;
          u32 num = elfReadLEB128(data, &bytes);
          data += bytes;
          int index = 0;
          while(num)
            {
              ELFAbbrev *abbr = elfGetAbbrev(unit->abbrevs, num);

              switch(abbr->tag)
                {
                case DW_TAG_member:
                {
                  if((index % 4) == 0)
                    s->members = (Member *)realloc(s->members,
                                                   sizeof(Member)*(index+4));
                  Member *m = &s->members[index];
                  m->location = NULL;
                  m->bitOffset = 0;
                  m->bitSize = 0;
                  m->byteSize = 0;
                  for(int i = 0; i < abbr->numAttrs; i++)
                    {
                      ELFAttr *attr = &abbr->attrs[i];
                      data = elfReadAttribute(data, attr);
                      switch(attr->name)
                        {
                        case DW_AT_name:
                          m->name = attr->string;
                          break;
                        case DW_AT_type:
                          m->type = elfParseType(unit, attr->value);
                          break;
                        case DW_AT_data_member_location:
                          m->location = attr->block;
                          break;
                        case DW_AT_byte_size:
                          m->byteSize = attr->value;
                          break;
                        case DW_AT_bit_offset:
                          m->bitOffset = attr->value;
                          break;
                        case DW_AT_bit_size:
                          m->bitSize = attr->value;
                          break;
                        case DW_AT_decl_file:
                        case DW_AT_decl_line:
                        case DW_AT_accessibility:
                        case DW_AT_artificial: // todo?
                          break;
                        default:
                          fprintf(stderr, "Unknown member attribute %02x\n",
                                  attr->name);
                        }
                    }
                  index++;
                }
                break;
                case DW_TAG_subprogram:
                {
                  Function *fnc = NULL;
                  data = elfParseFunction(data, abbr, unit, &fnc);
                  if(fnc != NULL)
                    {
                      if(unit->lastFunction)
                        unit->lastFunction->next = fnc;
                      else
                        unit->functions = fnc;
                      unit->lastFunction = fnc;
                    }
                }
                break;
                case DW_TAG_inheritance:
                  // TODO: add support
                  data = elfSkipData(data, abbr, unit->abbrevs);
                  break;
CASE_TYPE_TAG:
                  // skip types... parsed only when used
                  data = elfSkipData(data, abbr, unit->abbrevs);
                  break;
                case DW_TAG_variable:
                  data = elfSkipData(data, abbr, unit->abbrevs);
                  break;
                default:
                  fprintf(stderr, "Unknown struct tag %02x %s\n", abbr->tag, t->name);
                  data = elfSkipData(data, abbr, unit->abbrevs);
                  break;
                }
              num = elfReadLEB128(data, &bytes);
              data += bytes;
            }
          s->memberCount = index;
        }
      *type = t;
      return;
    }
    break;
    case DW_TAG_base_type:
    {
      Type *t = (Type *)calloc(sizeof(Type), 1);

      t->type = TYPE_base;
      elfAddType(t, unit, offset);
      for(int i = 0; i < abbrev->numAttrs; i++)
        {
          ELFAttr *attr = &abbrev->attrs[i];
          data = elfReadAttribute(data, attr);
          switch(attr->name)
            {
            case DW_AT_name:
              t->name = attr->string;
              break;
            case DW_AT_encoding:
              t->encoding = attr->value;
              break;
            case DW_AT_byte_size:
              t->size = attr->value;
              break;
            case DW_AT_bit_size:
              t->bitSize = attr->value;
              break;
            default:
              fprintf(stderr, "Unknown attribute for base type %02x\n",
                      attr->name);
              break;
            }
        }
      if(abbrev->hasChildren)
        fprintf(stderr, "Unexpected children for base type\n");
      *type = t;
      return;
    }
    break;
    case DW_TAG_pointer_type:
    {
      Type *t = (Type *)calloc(sizeof(Type), 1);

      t->type = TYPE_pointer;

      elfAddType(t, unit, offset);

      for(int i = 0; i < abbrev->numAttrs; i++)
        {
          ELFAttr *attr = &abbrev->attrs[i];
          data =elfReadAttribute(data, attr);
          switch(attr->name)
            {
            case DW_AT_type:
              t->pointer = elfParseType(unit, attr->value);
              break;
            case DW_AT_byte_size:
              t->size = attr->value;
              break;
            default:
              fprintf(stderr, "Unknown pointer type attribute %02x\n", attr->name);
              break;
            }
        }
      if(abbrev->hasChildren)
        fprintf(stderr, "Unexpected children for pointer type\n");
      *type = t;
      return;
    }
    break;
    case DW_TAG_reference_type:
    {
      Type *t = (Type *)calloc(sizeof(Type), 1);

      t->type = TYPE_reference;

      elfAddType(t, unit, offset);

      for(int i = 0; i < abbrev->numAttrs; i++)
        {
          ELFAttr *attr = &abbrev->attrs[i];
          data =elfReadAttribute(data, attr);
          switch(attr->name)
            {
            case DW_AT_type:
              t->pointer = elfParseType(unit, attr->value);
              break;
            case DW_AT_byte_size:
              t->size = attr->value;
              break;
            default:
              fprintf(stderr, "Unknown ref type attribute %02x\n", attr->name);
              break;
            }
        }
      if(abbrev->hasChildren)
        fprintf(stderr, "Unexpected children for ref type\n");
      *type = t;
      return;
    }
    break;
    case DW_TAG_volatile_type:
    {
      u32 typeref = 0;

      for(int i = 0; i < abbrev->numAttrs; i++)
        {
          ELFAttr *attr = &abbrev->attrs[i];
          data = elfReadAttribute(data, attr);
          switch(attr->name)
            {
            case DW_AT_type:
              typeref = attr->value;
              break;
            default:
              fprintf(stderr, "Unknown volatile attribute for type %02x\n",
                      attr->name);
              break;
            }
        }
      if(abbrev->hasChildren)
        fprintf(stderr, "Unexpected children for volatile type\n");
      *type = elfParseType(unit, typeref);
      return;
    }
    break;
    case DW_TAG_const_type:
    {
      u32 typeref = 0;

      for(int i = 0; i < abbrev->numAttrs; i++)
        {
          ELFAttr *attr = &abbrev->attrs[i];
          data = elfReadAttribute(data, attr);
          switch(attr->name)
            {
            case DW_AT_type:
              typeref = attr->value;
              break;
            default:
              fprintf(stderr, "Unknown const attribute for type %02x\n",
                      attr->name);
              break;
            }
        }
      if(abbrev->hasChildren)
        fprintf(stderr, "Unexpected children for const type\n");
      *type = elfParseType(unit, typeref);
      return;
    }
    break;
    case DW_TAG_enumeration_type:
    {
      Type *t = (Type *)calloc(sizeof(Type), 1);
      t->type = TYPE_enum;
      Enum *e = (Enum *)calloc(sizeof(Enum), 1);
      t->enumeration = e;
      elfAddType(t, unit, offset);
      int count = 0;
      for(int i = 0; i < abbrev->numAttrs; i++)
        {
          ELFAttr *attr = &abbrev->attrs[i];
          data = elfReadAttribute(data, attr);
          switch(attr->name)
            {
            case DW_AT_name:
              t->name = attr->string;
              break;
            case DW_AT_byte_size:
              t->size = attr->value;
              break;
            case DW_AT_sibling:
            case DW_AT_decl_file:
            case DW_AT_decl_line:
              break;
            default:
              fprintf(stderr, "Unknown enum attribute %02x\n", attr->name);
            }
        }
      if(abbrev->hasChildren)
        {
          int bytes;
          u32 num = elfReadLEB128(data, &bytes);
          data += bytes;
          while(num)
            {
              ELFAbbrev *abbr = elfGetAbbrev(unit->abbrevs, num);

              switch(abbr->tag)
                {
                case DW_TAG_enumerator:
                {
                  count++;
                  e->members = (EnumMember *)realloc(e->members,
                                                     count*sizeof(EnumMember));
                  EnumMember *m = &e->members[count-1];
                  for(int i = 0; i < abbr->numAttrs; i++)
                    {
                      ELFAttr *attr = &abbr->attrs[i];
                      data = elfReadAttribute(data, attr);
                      switch(attr->name)
                        {
                        case DW_AT_name:
                          m->name = attr->string;
                          break;
                        case DW_AT_const_value:
                          m->value = attr->value;
                          break;
                        default:
                          fprintf(stderr, "Unknown sub param attribute %02x\n",
                                  attr->name);
                        }
                    }
                }
                break;
                default:
                  fprintf(stderr, "Unknown enum tag %02x\n", abbr->tag);
                  data = elfSkipData(data, abbr, unit->abbrevs);
                  break;
                }
              num = elfReadLEB128(data, &bytes);
              data += bytes;
            }
        }
      e->count = count;
      *type = t;
      return;
    }
    break;
    case DW_TAG_subroutine_type:
    {
      Type *t = (Type *)calloc(sizeof(Type), 1);
      t->type = TYPE_function;
      FunctionType *f = (FunctionType *)calloc(sizeof(FunctionType), 1);
      t->function = f;
      elfAddType(t, unit, offset);
      for(int i = 0; i < abbrev->numAttrs; i++)
        {
          ELFAttr *attr = &abbrev->attrs[i];
          data = elfReadAttribute(data, attr);
          switch(attr->name)
            {
            case DW_AT_prototyped:
            case DW_AT_sibling:
              break;
            case DW_AT_type:
              f->returnType = elfParseType(unit, attr->value);
              break;
            default:
              fprintf(stderr, "Unknown subroutine attribute %02x\n", attr->name);
            }
        }
      if(abbrev->hasChildren)
        {
          int bytes;
          u32 num = elfReadLEB128(data, &bytes);
          data += bytes;
          Object *lastVar = NULL;
          while(num)
            {
              ELFAbbrev *abbr = elfGetAbbrev(unit->abbrevs, num);

              switch(abbr->tag)
                {
                case DW_TAG_formal_parameter:
                {
                  Object *o;
                  data = elfParseObject(data, abbr, unit, &o);
                  if(f->args)
                    lastVar->next = o;
                  else
                    f->args = o;
                  lastVar = o;
                }
                break;
                case DW_TAG_unspecified_parameters:
                  // no use in the debugger yet
                  data = elfSkipData(data, abbr, unit->abbrevs);
                  break;
CASE_TYPE_TAG:
                  // skip types... parsed only when used
                  data = elfSkipData(data, abbr, unit->abbrevs);
                  break;
                default:
                  fprintf(stderr, "Unknown subroutine tag %02x\n", abbr->tag);
                  data = elfSkipData(data, abbr, unit->abbrevs);
                  break;
                }
              num = elfReadLEB128(data, &bytes);
              data += bytes;
            }
        }
      *type = t;
      return;
    }
    break;
    case DW_TAG_array_type:
    {
      u32 typeref = 0;
      int i;
      Array *array = (Array *)calloc(sizeof(Array), 1);
      Type *t = (Type *)calloc(sizeof(Type), 1);
      t->type = TYPE_array;
      elfAddType(t, unit, offset);

      for(i = 0; i < abbrev->numAttrs; i++)
        {
          ELFAttr *attr = &abbrev->attrs[i];
          data = elfReadAttribute(data, attr);
          switch(attr->name)
            {
            case DW_AT_sibling:
              break;
            case DW_AT_type:
              typeref = attr->value;
              array->type = elfParseType(unit, typeref);
              break;
            default:
              fprintf(stderr, "Unknown array attribute %02x\n", attr->name);
            }
        }
      if(abbrev->hasChildren)
        {
          int bytes;
          u32 num = elfReadLEB128(data, &bytes);
          data += bytes;
          int index = 0;
          int maxBounds = 0;
          while(num)
            {
              ELFAbbrev *abbr = elfGetAbbrev(unit->abbrevs, num);

              switch(abbr->tag)
                {
                case DW_TAG_subrange_type:
                {
                  if(maxBounds == index)
                    {
                      maxBounds += 4;
                      array->bounds = (int *)realloc(array->bounds,
                                                     sizeof(int)*maxBounds);
                    }
                  for(int i = 0; i < abbr->numAttrs; i++)
                    {
                      ELFAttr *attr = &abbr->attrs[i];
                      data = elfReadAttribute(data, attr);
                      switch(attr->name)
                        {
                        case DW_AT_upper_bound:
                          array->bounds[index] = attr->value+1;
                          break;
                        case DW_AT_type: // ignore
                          break;
                        default:
                          fprintf(stderr, "Unknown subrange attribute %02x\n",
                                  attr->name);
                        }
                    }
                  index++;
                }
                break;
                default:
                  fprintf(stderr, "Unknown array tag %02x\n", abbr->tag);
                  data = elfSkipData(data, abbr, unit->abbrevs);
                  break;
                }
              num = elfReadLEB128(data, &bytes);
              data += bytes;
            }
          array->maxBounds = index;
        }
      t->size = array->type->size;
      for(i = 0; i < array->maxBounds; i++)
        t->size *= array->bounds[i];
      t->array = array;
      *type = t;
      return;
    }
    break;
    default:
      fprintf(stderr, "Unknown type TAG %02x\n", abbrev->tag);
      exit(-1);
    }
}

Type *elfParseType(CompileUnit *unit, u32 offset)
{
  Type *t = unit->types;

  while(t)
    {
      if(t->offset == offset)
        return t;
      t = t->next;
    }
  if(offset == 0)
    {
      Type *t = (Type *)calloc(sizeof(Type), 1);
      t->type = TYPE_void;
      t->offset = 0;
      elfAddType(t, unit, 0);
      return t;
    }
  u8 *data = unit->top + offset;
  int bytes;
  int abbrevNum = elfReadLEB128(data, &bytes);
  data += bytes;
  Type *type = NULL;

  ELFAbbrev *abbrev = elfGetAbbrev(unit->abbrevs, abbrevNum);

  elfParseType(data, offset, abbrev, unit, &type);
  return type;
}

void elfGetObjectAttributes(CompileUnit *unit, u32 offset, Object *o)
{
  u8 *data = unit->top + offset;
  int bytes;
  u32 abbrevNum = elfReadLEB128(data, &bytes);
  data += bytes;

  if(!abbrevNum)
    {
      return;
    }

  ELFAbbrev *abbrev = elfGetAbbrev(unit->abbrevs, abbrevNum);

  for(int i = 0; i < abbrev->numAttrs; i++)
    {
      ELFAttr *attr = &abbrev->attrs[i];
      data = elfReadAttribute(data, attr);
      switch(attr->name)
        {
        case DW_AT_location:
          o->location = attr->block;
          break;
        case DW_AT_name:
          if(o->name == NULL)
            o->name = attr->string;
          break;
        case DW_AT_MIPS_linkage_name:
          o->name = attr->string;
          break;
        case DW_AT_decl_file:
          o->file = attr->value;
          break;
        case DW_AT_decl_line:
          o->line = attr->value;
          break;
        case DW_AT_type:
          o->type = elfParseType(unit, attr->value);
          break;
        case DW_AT_external:
          o->external = attr->flag;
          break;
        case DW_AT_const_value:
        case DW_AT_abstract_origin:
        case DW_AT_declaration:
        case DW_AT_artificial:
          // todo
          break;
        case DW_AT_specification:
          // TODO:
          break;
        default:
          fprintf(stderr, "Unknown object attribute %02x\n", attr->name);
          break;
        }
    }
}

u8 *elfParseObject(u8 *data, ELFAbbrev *abbrev, CompileUnit *unit,
                   Object **object)
{
  Object *o = (Object *)calloc(sizeof(Object), 1);

  o->next = NULL;

  for(int i = 0; i < abbrev->numAttrs; i++)
    {
      ELFAttr *attr = &abbrev->attrs[i];
      data = elfReadAttribute(data, attr);
      switch(attr->name)
        {
        case DW_AT_location:
          o->location = attr->block;
          break;
        case DW_AT_name:
          if(o->name == NULL)
            o->name = attr->string;
          break;
        case DW_AT_MIPS_linkage_name:
          o->name = attr->string;
          break;
        case DW_AT_decl_file:
          o->file = attr->value;
          break;
        case DW_AT_decl_line:
          o->line = attr->value;
          break;
        case DW_AT_type:
          o->type = elfParseType(unit, attr->value);
          break;
        case DW_AT_external:
          o->external = attr->flag;
          break;
        case DW_AT_abstract_origin:
          elfGetObjectAttributes(unit, attr->value, o);
          break;
        case DW_AT_const_value:
        case DW_AT_declaration:
        case DW_AT_artificial:
          break;
        case DW_AT_specification:
          // TODO:
          break;
        default:
          fprintf(stderr, "Unknown object attribute %02x\n", attr->name);
          break;
        }
    }
  *object = o;
  return data;
}

u8 *elfParseBlock(u8 *data, ELFAbbrev *abbrev, CompileUnit *unit,
                  Function *func, Object **lastVar)
{
  int bytes;
  u32 start = func->lowPC;
  u32 end = func->highPC;

  for(int i = 0; i < abbrev->numAttrs; i++)
    {
      ELFAttr *attr = &abbrev->attrs[i];
      data = elfReadAttribute(data, attr);
      switch(attr->name)
        {
        case DW_AT_sibling:
          break;
        case DW_AT_low_pc:
          start = attr->value;
          break;
        case DW_AT_high_pc:
          end = attr->value;
          break;
        case DW_AT_ranges: // ignore for now
          break;
        default:
          fprintf(stderr, "Unknown block attribute %02x\n", attr->name);
          break;
        }
    }

  if(abbrev->hasChildren)
    {
      int nesting = 1;

      while(nesting)
        {
          u32 abbrevNum = elfReadLEB128(data, &bytes);
          data += bytes;

          if(!abbrevNum)
            {
              nesting--;
              continue;
            }

          abbrev = elfGetAbbrev(unit->abbrevs, abbrevNum);

          switch(abbrev->tag)
            {
CASE_TYPE_TAG: // types only parsed when used
            case DW_TAG_label: // not needed
              data = elfSkipData(data, abbrev, unit->abbrevs);
              break;
            case DW_TAG_lexical_block:
              data = elfParseBlock(data, abbrev, unit, func, lastVar);
              break;
            case DW_TAG_subprogram:
            {
              Function *f = NULL;
              data = elfParseFunction(data, abbrev, unit, &f);
              if(f != NULL)
                {
                  if(unit->lastFunction)
                    unit->lastFunction->next = f;
                  else
                    unit->functions = f;
                  unit->lastFunction = f;
                }
            }
            break;
            case DW_TAG_variable:
            {
              Object *o;
              data = elfParseObject(data, abbrev, unit, &o);
              if(o->startScope == 0)
                o->startScope = start;
              if(o->endScope == 0)
                o->endScope = 0;
              if(func->variables)
                (*lastVar)->next = o;
              else
                func->variables = o;
              *lastVar = o;
            }
            break;
            case DW_TAG_inlined_subroutine:
              // TODO:
              data = elfSkipData(data, abbrev, unit->abbrevs);
              break;
            default:
            {
              fprintf(stderr, "Unknown block TAG %02x\n", abbrev->tag);
              data = elfSkipData(data, abbrev, unit->abbrevs);
            }
            break;
            }
        }
    }
  return data;
}

void elfGetFunctionAttributes(CompileUnit *unit, u32 offset, Function *func)
{
  u8 *data = unit->top + offset;
  int bytes;
  u32 abbrevNum = elfReadLEB128(data, &bytes);
  data += bytes;

  if(!abbrevNum)
    {
      return;
    }

  ELFAbbrev *abbrev = elfGetAbbrev(unit->abbrevs, abbrevNum);

  for(int i = 0; i < abbrev->numAttrs; i++)
    {
      ELFAttr *attr = &abbrev->attrs[i];
      data = elfReadAttribute(data, attr);

      switch(attr->name)
        {
        case DW_AT_sibling:
          break;
        case DW_AT_name:
          if(func->name == NULL)
            func->name = attr->string;
          break;
        case DW_AT_MIPS_linkage_name:
          func->name = attr->string;
          break;
        case DW_AT_low_pc:
          func->lowPC = attr->value;
          break;
        case DW_AT_high_pc:
          func->highPC = attr->value;
          break;
        case DW_AT_decl_file:
          func->file = attr->value;
          break;
        case DW_AT_decl_line:
          func->line = attr->value;
          break;
        case DW_AT_external:
          func->external = attr->flag;
          break;
        case DW_AT_frame_base:
          func->frameBase = attr->block;
          break;
        case DW_AT_type:
          func->returnType = elfParseType(unit, attr->value);
          break;
        case DW_AT_inline:
        case DW_AT_specification:
        case DW_AT_declaration:
        case DW_AT_artificial:
        case DW_AT_prototyped:
        case DW_AT_proc_body:
        case DW_AT_save_offset:
        case DW_AT_user_2002:
        case DW_AT_virtuality:
        case DW_AT_containing_type:
        case DW_AT_accessibility:
          // todo;
          break;
        case DW_AT_vtable_elem_location:
          free(attr->block);
          break;
        default:
          fprintf(stderr, "Unknown function attribute %02x\n", attr->name);
          break;
        }
    }

  return;
}

u8 *elfParseFunction(u8 *data, ELFAbbrev *abbrev, CompileUnit *unit,
                     Function **f)
{
  Function *func = (Function *)calloc(sizeof(Function), 1);
  *f = func;

  int bytes;
  bool mangled = false;
  bool declaration = false;
  for(int i = 0; i < abbrev->numAttrs; i++)
    {
      ELFAttr *attr = &abbrev->attrs[i];
      data = elfReadAttribute(data, attr);
      switch(attr->name)
        {
        case DW_AT_sibling:
          break;
        case DW_AT_name:
          if(func->name == NULL)
            func->name = attr->string;
          break;
        case DW_AT_MIPS_linkage_name:
          func->name = attr->string;
          mangled = true;
          break;
        case DW_AT_low_pc:
          func->lowPC = attr->value;
          break;
        case DW_AT_high_pc:
          func->highPC = attr->value;
          break;
        case DW_AT_prototyped:
          break;
        case DW_AT_decl_file:
          func->file = attr->value;
          break;
        case DW_AT_decl_line:
          func->line = attr->value;
          break;
        case DW_AT_external:
          func->external = attr->flag;
          break;
        case DW_AT_frame_base:
          func->frameBase = attr->block;
          break;
        case DW_AT_type:
          func->returnType = elfParseType(unit, attr->value);
          break;
        case DW_AT_abstract_origin:
          elfGetFunctionAttributes(unit, attr->value, func);
          break;
        case DW_AT_declaration:
          declaration = attr->flag;
          break;
        case DW_AT_inline:
        case DW_AT_specification:
        case DW_AT_artificial:
        case DW_AT_proc_body:
        case DW_AT_save_offset:
        case DW_AT_user_2002:
        case DW_AT_virtuality:
        case DW_AT_containing_type:
        case DW_AT_accessibility:
          // todo;
          break;
        case DW_AT_vtable_elem_location:
          free(attr->block);
          break;
        default:
          fprintf(stderr, "Unknown function attribute %02x\n", attr->name);
          break;
        }
    }

  if(declaration)
    {
      elfCleanUp(func);
      free(func);
      *f = NULL;

      while(1)
        {
          u32 abbrevNum = elfReadLEB128(data, &bytes);
          data += bytes;

          if(!abbrevNum)
            {
              return data;
            }

          abbrev = elfGetAbbrev(unit->abbrevs, abbrevNum);

          data = elfSkipData(data, abbrev, unit->abbrevs);
        }
    }

  if(abbrev->hasChildren)
    {
      int nesting = 1;
      Object *lastParam = NULL;
      Object *lastVar = NULL;

      while(nesting)
        {
          u32 abbrevNum = elfReadLEB128(data, &bytes);
          data += bytes;

          if(!abbrevNum)
            {
              nesting--;
              continue;
            }

          abbrev = elfGetAbbrev(unit->abbrevs, abbrevNum);

          switch(abbrev->tag)
            {
CASE_TYPE_TAG: // no need to parse types. only parsed when used
            case DW_TAG_label: // not needed
              data = elfSkipData(data, abbrev, unit->abbrevs);
              break;
            case DW_TAG_subprogram:
            {
              Function *fnc=NULL;
              data = elfParseFunction(data, abbrev, unit, &fnc);
              if(fnc != NULL)
                {
                  if(unit->lastFunction == NULL)
                    unit->functions = fnc;
                  else
                    unit->lastFunction->next = fnc;
                  unit->lastFunction = fnc;
                }
            }
            break;
            case DW_TAG_lexical_block:
            {
              data = elfParseBlock(data, abbrev, unit, func, &lastVar);
            }
            break;
            case DW_TAG_formal_parameter:
            {
              Object *o;
              data = elfParseObject(data, abbrev, unit, &o);
              if(func->parameters)
                lastParam->next = o;
              else
                func->parameters = o;
              lastParam = o;
            }
            break;
            case DW_TAG_variable:
            {
              Object *o;
              data = elfParseObject(data, abbrev, unit, &o);
              if(func->variables)
                lastVar->next = o;
              else
                func->variables = o;
              lastVar = o;
            }
            break;
            case DW_TAG_unspecified_parameters:
            case DW_TAG_inlined_subroutine:
            {
              // todo
              for(int i = 0; i < abbrev->numAttrs; i++)
                {
                  data = elfReadAttribute(data,  &abbrev->attrs[i]);
                  if(abbrev->attrs[i].form == DW_FORM_block1)
                    free(abbrev->attrs[i].block);
                }

              if(abbrev->hasChildren)
                nesting++;
            }
            break;
            default:
            {
              fprintf(stderr, "Unknown function TAG %02x\n", abbrev->tag);
              data = elfSkipData(data, abbrev, unit->abbrevs);
            }
            break;
            }
        }
    }
  return data;
}

u8 *elfParseUnknownData(u8 *data, ELFAbbrev *abbrev, ELFAbbrev **abbrevs)
{
  int i;
  int bytes;
  //  switch(abbrev->tag) {
  //  default:
  fprintf(stderr, "Unknown TAG %02x\n", abbrev->tag);

  for(i = 0; i < abbrev->numAttrs; i++)
    {
      data = elfReadAttribute(data,  &abbrev->attrs[i]);
      if(abbrev->attrs[i].form == DW_FORM_block1)
        free(abbrev->attrs[i].block);
    }

  if(abbrev->hasChildren)
    {
      int nesting = 1;
      while(nesting)
        {
          u32 abbrevNum = elfReadLEB128(data, &bytes);
          data += bytes;

          if(!abbrevNum)
            {
              nesting--;
              continue;
            }

          abbrev = elfGetAbbrev(abbrevs, abbrevNum);

          fprintf(stderr, "Unknown TAG %02x\n", abbrev->tag);

          for(i = 0; i < abbrev->numAttrs; i++)
            {
              data = elfReadAttribute(data,  &abbrev->attrs[i]);
              if(abbrev->attrs[i].form == DW_FORM_block1)
                free(abbrev->attrs[i].block);
            }

          if(abbrev->hasChildren)
            {
              nesting++;
            }
        }
    }
  //  }
  return data;
}

u8 *elfParseCompileUnitChildren(u8 *data, CompileUnit *unit)
{
  int bytes;
  u32 abbrevNum = elfReadLEB128(data, &bytes);
  data += bytes;
  Object *lastObj = NULL;
  while(abbrevNum)
    {
      ELFAbbrev *abbrev = elfGetAbbrev(unit->abbrevs, abbrevNum);
      switch(abbrev->tag)
        {
        case DW_TAG_subprogram:
        {
          Function *func = NULL;
          data = elfParseFunction(data, abbrev, unit, &func);
          if(func != NULL)
            {
              if(unit->lastFunction)
                unit->lastFunction->next = func;
              else
                unit->functions = func;
              unit->lastFunction = func;
            }
        }
        break;
CASE_TYPE_TAG:
        data = elfSkipData(data, abbrev, unit->abbrevs);
        break;
        case DW_TAG_variable:
        {
          Object *var = NULL;
          data = elfParseObject(data, abbrev, unit, &var);
          if(lastObj)
            lastObj->next = var;
          else
            unit->variables = var;
          lastObj = var;
        }
        break;
        default:
          data = elfParseUnknownData(data, abbrev, unit->abbrevs);
          break;
        }

      abbrevNum = elfReadLEB128(data, &bytes);
      data += bytes;
    }
  return data;
}


CompileUnit *elfParseCompUnit(u8 *data, u8 *abbrevData)
{
  int bytes;
  u8 *top = data;

  u32 length = elfRead4Bytes(data);
  data += 4;

  u16 version = elfRead2Bytes(data);
  data += 2;

  u32 offset = elfRead4Bytes(data);
  data += 4;

  u8 addrSize = *data++;

  if(version != 2)
    {
      fprintf(stderr, "Unsupported debugging information version %d\n", version);
      return NULL;
    }

  if(addrSize != 4)
    {
      fprintf(stderr, "Unsupported address size %d\n", addrSize);
      return NULL;
    }

  ELFAbbrev **abbrevs = elfReadAbbrevs(abbrevData, offset);

  u32 abbrevNum = elfReadLEB128(data, &bytes);
  data += bytes;

  ELFAbbrev *abbrev = elfGetAbbrev(abbrevs, abbrevNum);

  CompileUnit *unit = (CompileUnit *)calloc(sizeof(CompileUnit), 1);
  unit->top = top;
  unit->length = length;
  unit->abbrevs = abbrevs;
  unit->next = NULL;

  elfCurrentUnit = unit;

  int i;

  for(i = 0; i < abbrev->numAttrs; i++)
    {
      ELFAttr *attr = &abbrev->attrs[i];
      data = elfReadAttribute(data, attr);

      switch(attr->name)
        {
        case DW_AT_name:
          unit->name = attr->string;
          break;
        case DW_AT_stmt_list:
          unit->hasLineInfo = true;
          unit->lineInfo = attr->value;
          break;
        case DW_AT_low_pc:
          unit->lowPC = attr->value;
          break;
        case DW_AT_high_pc:
          unit->highPC = attr->value;
          break;
        case DW_AT_compdir:
          unit->compdir = attr->string;
          break;
          // ignore
        case DW_AT_language:
        case DW_AT_producer:
        case DW_AT_macro_info:
        case DW_AT_entry_pc:
          break;
        default:
          fprintf(stderr, "Unknown attribute %02x\n", attr->name);
          break;
        }
    }

  if(abbrev->hasChildren)
    elfParseCompileUnitChildren(data, unit);

  return unit;
}

void elfParseAranges(u8 *data)
{
  ELFSectionHeader *sh = elfGetSectionByName(".debug_aranges");
  if(sh == NULL)
    {
      fprintf(stderr, "No aranges found\n");
      return;
    }

  data = elfReadSection(data, sh);
  u8 *end = data + READ32LE(&sh->size);

  int max = 4;
  ARanges *ranges = (ARanges *)calloc(sizeof(ARanges), 4);

  int index = 0;

  while(data < end)
    {
      u32 len = elfRead4Bytes(data);
      data += 4;
      //    u16 version = elfRead2Bytes(data);
      data += 2;
      u32 offset = elfRead4Bytes(data);
      data += 4;
      //    u8 addrSize = *data++;
      //    u8 segSize = *data++;
      data += 2; // remove if uncommenting above
      data += 4;
      ranges[index].count = (len-20)/8;
      ranges[index].offset = offset;
      ranges[index].ranges = (ARange *)calloc(sizeof(ARange), (len-20)/8);
      int i = 0;
      while(true)
        {
          u32 addr = elfRead4Bytes(data);
          data += 4;
          u32 len = elfRead4Bytes(data);
          data += 4;
          if(addr == 0 && len == 0)
            break;
          ranges[index].ranges[i].lowPC = addr;
          ranges[index].ranges[i].highPC = addr+len;
          i++;
        }
      index++;
      if(index == max)
        {
          max += 4;
          ranges = (ARanges *)realloc(ranges, max*sizeof(ARanges));
        }
    }
  elfDebugInfo->numRanges = index;
  elfDebugInfo->ranges = ranges;
}

void elfReadSymtab(u8 *data)
{
  ELFSectionHeader *sh = elfGetSectionByName(".symtab");
  int table = READ32LE(&sh->link);

  char *strtable = (char *)elfReadSection(data, elfGetSectionByNumber(table));

  ELFSymbol *symtab = (ELFSymbol *)elfReadSection(data, sh);

  int count = READ32LE(&sh->size) / sizeof(ELFSymbol);
  elfSymbolsCount = 0;

  elfSymbols = (Symbol *)malloc(sizeof(Symbol)*count);

  int i;

  for(i = 0; i < count; i++)
    {
      ELFSymbol *s = &symtab[i];
      int type = s->info & 15;
      int binding = s->info >> 4;

      if(binding)
        {
          Symbol *sym = &elfSymbols[elfSymbolsCount];
          sym->name = &strtable[READ32LE(&s->name)];
          sym->binding = binding;
          sym->type = type;
          sym->value = READ32LE(&s->value);
          sym->size = READ32LE(&s->size);
          elfSymbolsCount++;
        }
    }
  for(i = 0; i < count; i++)
    {
      ELFSymbol *s = &symtab[i];
      int bind = s->info>>4;
      int type = s->info & 15;

      if(!bind)
        {
          Symbol *sym = &elfSymbols[elfSymbolsCount];
          sym->name = &strtable[READ32LE(&s->name)];
          sym->binding = (s->info >> 4);
          sym->type = type;
          sym->value = READ32LE(&s->value);
          sym->size = READ32LE(&s->size);
          elfSymbolsCount++;
        }
    }
  elfSymbolsStrTab = strtable;
  //  free(symtab);
}

bool elfReadProgram(ELFHeader *eh, u8 *data, int& size, bool parseDebug)
{
  int count = READ16LE(&eh->e_phnum);
  int i;

  if(READ32LE(&eh->e_entry) == 0x2000000)
    cpuIsMultiBoot = true;

  // read program headers... should probably move this code down
  u8 *p = data + READ32LE(&eh->e_phoff);
  size = 0;
  for(i = 0; i < count; i++)
    {
      ELFProgramHeader *ph = (ELFProgramHeader *)p;
      p += sizeof(ELFProgramHeader);
      if(READ16LE(&eh->e_phentsize) != sizeof(ELFProgramHeader))
        {
          p += READ16LE(&eh->e_phentsize) - sizeof(ELFProgramHeader);
        }

      //    printf("PH %d %08x %08x %08x %08x %08x %08x %08x %08x\n",
      //     i, ph->type, ph->offset, ph->vaddr, ph->paddr,
      //     ph->filesz, ph->memsz, ph->flags, ph->align);
      if(cpuIsMultiBoot)
        {
          if(READ32LE(&ph->paddr) >= 0x2000000 &&
              READ32LE(&ph->paddr) <= 0x203ffff)
            {
              memcpy(&workRAM[READ32LE(&ph->paddr) & 0x3ffff],
                     data + READ32LE(&ph->offset),
                     READ32LE(&ph->filesz));
            }
        }
      else
        {
          if(READ32LE(&ph->paddr) >= 0x8000000 &&
              READ32LE(&ph->paddr) <= 0x9ffffff)
            {
              memcpy(&rom[READ32LE(&ph->paddr) & 0x1ffffff],
                     data + READ32LE(&ph->offset),
                     READ32LE(&ph->filesz));
              size += READ32LE(&ph->filesz);
            }
        }
    }

  char *stringTable = NULL;

  // read section headers
  p = data + READ32LE(&eh->e_shoff);
  count = READ16LE(&eh->e_shnum);

  ELFSectionHeader **sh = (ELFSectionHeader **)
                          malloc(sizeof(ELFSectionHeader *) * count);

  for(i = 0; i < count; i++)
    {
      sh[i] = (ELFSectionHeader *)p;
      p += sizeof(ELFSectionHeader);
      if(READ16LE(&eh->e_shentsize) != sizeof(ELFSectionHeader))
        p += READ16LE(&eh->e_shentsize) - sizeof(ELFSectionHeader);
    }

  if(READ16LE(&eh->e_shstrndx) != 0)
    {
      stringTable = (char *)elfReadSection(data,
                                           sh[READ16LE(&eh->e_shstrndx)]);
    }

  elfSectionHeaders = sh;
  elfSectionHeadersStringTable = stringTable;
  elfSectionHeadersCount = count;

  for(i = 0; i < count; i++)
    {
      //    printf("SH %d %-20s %08x %08x %08x %08x %08x %08x %08x %08x\n",
      //   i, &stringTable[sh[i]->name], sh[i]->name, sh[i]->type,
      //   sh[i]->flags, sh[i]->addr, sh[i]->offset, sh[i]->size,
      //   sh[i]->link, sh[i]->info);
      if(READ32LE(&sh[i]->flags) & 2)
        { // load section
          if(cpuIsMultiBoot)
            {
              if(READ32LE(&sh[i]->addr) >= 0x2000000 &&
                  READ32LE(&sh[i]->addr) <= 0x203ffff)
                {
                  memcpy(&workRAM[READ32LE(&sh[i]->addr) & 0x3ffff], data +
                         READ32LE(&sh[i]->offset),
                         READ32LE(&sh[i]->size));
                }
            }
          else
            {
              if(READ32LE(&sh[i]->addr) >= 0x8000000 &&
                  READ32LE(&sh[i]->addr) <= 0x9ffffff)
                {
                  memcpy(&rom[READ32LE(&sh[i]->addr) & 0x1ffffff],
                         data + READ32LE(&sh[i]->offset),
                         READ32LE(&sh[i]->size));
                  size += READ32LE(&sh[i]->size);
                }
            }
        }
    }

  if(parseDebug)
    {
      fprintf(stderr, "Parsing debug info\n");

      ELFSectionHeader *dbgHeader = elfGetSectionByName(".debug_info");
      if(dbgHeader == NULL)
        {
          fprintf(stderr, "Cannot find debug information\n");
          goto end;
        }

      ELFSectionHeader *h = elfGetSectionByName(".debug_abbrev");
      if(h == NULL)
        {
          fprintf(stderr, "Cannot find abbreviation table\n");
          goto end;
        }

      elfDebugInfo = (DebugInfo *)calloc(sizeof(DebugInfo), 1);
      u8 *abbrevdata = elfReadSection(data, h);

      h = elfGetSectionByName(".debug_str");

      if(h == NULL)
        elfDebugStrings = NULL;
      else
        elfDebugStrings = (char *)elfReadSection(data, h);

      u8 *debugdata = elfReadSection(data, dbgHeader);

      elfDebugInfo->debugdata = data;
      elfDebugInfo->infodata = debugdata;

      u32 total = READ32LE(&dbgHeader->size);
      u8 *end = debugdata + total;
      u8 *ddata = debugdata;

      CompileUnit *last = NULL;
      CompileUnit *unit = NULL;

      while(ddata < end)
        {
          unit = elfParseCompUnit(ddata, abbrevdata);
          unit->offset = ddata-debugdata;
          elfParseLineInfo(unit, data);
          if(last == NULL)
            elfCompileUnits = unit;
          else
            last->next = unit;
          last = unit;
          ddata += 4 + unit->length;
        }
      elfParseAranges(data);
      CompileUnit *comp = elfCompileUnits;
      while(comp)
        {
          ARanges *r = elfDebugInfo->ranges;
          for(int i = 0; i < elfDebugInfo->numRanges; i++)
            if(r[i].offset == comp->offset)
              {
                comp->ranges = &r[i];
                break;
              }
          comp = comp->next;
        }
      elfParseCFA(data);
      elfReadSymtab(data);
    }
end:
  if(sh)
    {
      free(sh);
    }

  elfSectionHeaders = NULL;
  elfSectionHeadersStringTable = NULL;
  elfSectionHeadersCount = 0;

  return true;
}

extern bool parseDebug;

bool elfRead(const char *name, int& siz, FILE* f)
{

  fseek(f, 0, SEEK_END);
  long size = ftell(f);

  elfFileData = (u8 *)malloc(size);
  gen_fseek(f, 0, SEEK_SET);
  gen_fread(elfFileData, 1, size, f);
  gen_fclose(f);

  ELFHeader *header = (ELFHeader *)elfFileData;

  if(READ32LE(&header->magic) != 0x464C457F ||
      READ16LE(&header->e_machine) != 40 ||
      header->clazz != 1)
    {
      systemMessage(0, N_("Not a valid ELF file %s"), name);
      free(elfFileData);
      elfFileData = NULL;
      return false;
    }

  if(!elfReadProgram(header, elfFileData, siz, parseDebug))
    {
      free(elfFileData);
      elfFileData = NULL;
      return false;
    }

  return true;
}

void elfCleanUp(Object *o)
{
  free(o->location);
}

void elfCleanUp(Function *func)
{
  Object *o = func->parameters;
  while(o)
    {
      elfCleanUp(o);
      Object *next = o->next;
      free(o);
      o = next;
    }

  o = func->variables;
  while(o)
    {
      elfCleanUp(o);
      Object *next = o->next;
      free(o);
      o = next;
    }
  free(func->frameBase);
}

void elfCleanUp(ELFAbbrev **abbrevs)
{
  for(int i = 0; i < 121; i++)
    {
      ELFAbbrev *abbrev = abbrevs[i];

      while(abbrev)
        {
          free(abbrev->attrs);
          ELFAbbrev *next = abbrev->next;
          free(abbrev);

          abbrev = next;
        }
    }
}

void elfCleanUp(Type *t)
{
  switch(t->type)
    {
    case TYPE_function:
      if(t->function)
        {
          Object *o = t->function->args;
          while(o)
            {
              elfCleanUp(o);
              Object *next = o->next;
              free(o);
              o = next;
            }
          free(t->function);
        }
      break;
    case TYPE_array:
      if(t->array)
        {
          free(t->array->bounds);
          free(t->array);
        }
      break;
    case TYPE_struct:
    case TYPE_union:
      if(t->structure)
        {
          for(int i = 0; i < t->structure->memberCount; i++)
            {
              free(t->structure->members[i].location);
            }
          free(t->structure->members);
          free(t->structure);
        }
      break;
    case TYPE_enum:
      if(t->enumeration)
        {
          free(t->enumeration->members);
          free(t->enumeration);
        }
      break;
    case TYPE_base:
    case TYPE_pointer:
    case TYPE_void:
    case TYPE_reference:
      break; // nothing to do
    }
}

void elfCleanUp(CompileUnit *comp)
{
  elfCleanUp(comp->abbrevs);
  free(comp->abbrevs);
  Function *func = comp->functions;
  while(func)
    {
      elfCleanUp(func);
      Function *next = func->next;
      free(func);
      func = next;
    }
  Type *t = comp->types;
  while(t)
    {
      elfCleanUp(t);
      Type *next = t->next;
      free(t);
      t = next;
    }
  Object *o = comp->variables;
  while(o)
    {
      elfCleanUp(o);
      Object *next = o->next;
      free(o);
      o = next;
    }
  if(comp->lineInfoTable)
    {
      free(comp->lineInfoTable->lines);
      free(comp->lineInfoTable->files);
      free(comp->lineInfoTable);
    }
}

void elfCleanUp()
{
  CompileUnit *comp = elfCompileUnits;

  while(comp)
    {
      elfCleanUp(comp);
      CompileUnit *next = comp->next;
      free(comp);
      comp = next;
    }
  elfCompileUnits = NULL;
  free(elfSymbols);
  elfSymbols = NULL;
  //  free(elfSymbolsStrTab);
  elfSymbolsStrTab = NULL;

  elfDebugStrings = NULL;
  if(elfDebugInfo)
    {
      int num = elfDebugInfo->numRanges;
      int i;
      for(i = 0; i < num; i++)
        {
          free(elfDebugInfo->ranges[i].ranges);
        }
      free(elfDebugInfo->ranges);
      free(elfDebugInfo);
      elfDebugInfo = NULL;
    }

  if(elfFdes)
    {
      if(elfFdeCount)
        {
          for(int i = 0; i < elfFdeCount; i++)
            free(elfFdes[i]);
        }
      free(elfFdes);

      elfFdes = NULL;
      elfFdeCount = 0;
    }

  ELFcie *cie = elfCies;
  while(cie)
    {
      ELFcie *next = cie->next;
      free(cie);
      cie = next;
    }
  elfCies = NULL;

  if(elfFileData)
    {
      free(elfFileData);
      elfFileData = NULL;
    }
}