Mercurial > vba-clojure

     1 #include <cstdio>

     2 #include <cstdlib>

     3 #include <cstring>

     4 

     5 #include "../Port.h"

     6 #include "../NLS.h"

     7 #include "../common/System.h" // systemMessage

     8 #include "GBAGlobals.h"

     9 #include "elf.h"

    10 

    11 #define elfReadMemory(addr) \

    12     READ32LE((&map[(addr)>>24].address[(addr) & map[(addr)>>24].mask]))

    13 

    14 #define DW_TAG_array_type             0x01

    15 #define DW_TAG_enumeration_type       0x04

    16 #define DW_TAG_formal_parameter       0x05

    17 #define DW_TAG_label                  0x0a

    18 #define DW_TAG_lexical_block          0x0b

    19 #define DW_TAG_member                 0x0d

    20 #define DW_TAG_pointer_type           0x0f

    21 #define DW_TAG_reference_type         0x10

    22 #define DW_TAG_compile_unit           0x11

    23 #define DW_TAG_structure_type         0x13

    24 #define DW_TAG_subroutine_type        0x15

    25 #define DW_TAG_typedef                0x16

    26 #define DW_TAG_union_type             0x17

    27 #define DW_TAG_unspecified_parameters 0x18

    28 #define DW_TAG_inheritance            0x1c

    29 #define DW_TAG_inlined_subroutine     0x1d

    30 #define DW_TAG_subrange_type          0x21

    31 #define DW_TAG_base_type              0x24

    32 #define DW_TAG_const_type             0x26

    33 #define DW_TAG_enumerator             0x28

    34 #define DW_TAG_subprogram             0x2e

    35 #define DW_TAG_variable               0x34

    36 #define DW_TAG_volatile_type          0x35

    37 

    38 #define DW_AT_sibling              0x01

    39 #define DW_AT_location             0x02

    40 #define DW_AT_name                 0x03

    41 #define DW_AT_byte_size            0x0b

    42 #define DW_AT_bit_offset           0x0c

    43 #define DW_AT_bit_size             0x0d

    44 #define DW_AT_stmt_list            0x10

    45 #define DW_AT_low_pc               0x11

    46 #define DW_AT_high_pc              0x12

    47 #define DW_AT_language             0x13

    48 #define DW_AT_compdir              0x1b

    49 #define DW_AT_const_value          0x1c

    50 #define DW_AT_containing_type      0x1d

    51 #define DW_AT_inline               0x20

    52 #define DW_AT_producer             0x25

    53 #define DW_AT_prototyped           0x27

    54 #define DW_AT_upper_bound          0x2f

    55 #define DW_AT_abstract_origin      0x31

    56 #define DW_AT_accessibility        0x32

    57 #define DW_AT_artificial           0x34

    58 #define DW_AT_data_member_location 0x38

    59 #define DW_AT_decl_file            0x3a

    60 #define DW_AT_decl_line            0x3b

    61 #define DW_AT_declaration          0x3c

    62 #define DW_AT_encoding             0x3e

    63 #define DW_AT_external             0x3f

    64 #define DW_AT_frame_base           0x40

    65 #define DW_AT_macro_info           0x43

    66 #define DW_AT_specification        0x47

    67 #define DW_AT_type                 0x49

    68 #define DW_AT_virtuality           0x4c

    69 #define DW_AT_vtable_elem_location 0x4d

    70 // DWARF 2.1/3.0 extensions

    71 #define DW_AT_entry_pc             0x52

    72 #define DW_AT_ranges               0x55

    73 // ARM Compiler extensions

    74 #define DW_AT_proc_body            0x2000

    75 #define DW_AT_save_offset          0x2001

    76 #define DW_AT_user_2002            0x2002

    77 // MIPS extensions

    78 #define DW_AT_MIPS_linkage_name    0x2007

    79 

    80 #define DW_FORM_addr      0x01

    81 #define DW_FORM_data2     0x05

    82 #define DW_FORM_data4     0x06

    83 #define DW_FORM_string    0x08

    84 #define DW_FORM_block     0x09

    85 #define DW_FORM_block1    0x0a

    86 #define DW_FORM_data1     0x0b

    87 #define DW_FORM_flag      0x0c

    88 #define DW_FORM_sdata     0x0d

    89 #define DW_FORM_strp      0x0e

    90 #define DW_FORM_udata     0x0f

    91 #define DW_FORM_ref_addr  0x10

    92 #define DW_FORM_ref4      0x13

    93 #define DW_FORM_ref_udata 0x15

    94 #define DW_FORM_indirect  0x16

    95 

    96 #define DW_OP_addr        0x03

    97 #define DW_OP_plus_uconst 0x23

    98 #define DW_OP_reg0        0x50

    99 #define DW_OP_reg1        0x51

   100 #define DW_OP_reg2        0x52

   101 #define DW_OP_reg3        0x53

   102 #define DW_OP_reg4        0x54

   103 #define DW_OP_reg5        0x55

   104 #define DW_OP_reg6        0x56

   105 #define DW_OP_reg7        0x57

   106 #define DW_OP_reg8        0x58

   107 #define DW_OP_reg9        0x59

   108 #define DW_OP_reg10       0x5a

   109 #define DW_OP_reg11       0x5b

   110 #define DW_OP_reg12       0x5c

   111 #define DW_OP_reg13       0x5d

   112 #define DW_OP_reg14       0x5e

   113 #define DW_OP_reg15       0x5f

   114 #define DW_OP_fbreg       0x91

   115 

   116 #define DW_LNS_extended_op      0x00

   117 #define DW_LNS_copy             0x01

   118 #define DW_LNS_advance_pc       0x02

   119 #define DW_LNS_advance_line     0x03

   120 #define DW_LNS_set_file         0x04

   121 #define DW_LNS_set_column       0x05

   122 #define DW_LNS_negate_stmt      0x06

   123 #define DW_LNS_set_basic_block  0x07

   124 #define DW_LNS_const_add_pc     0x08

   125 #define DW_LNS_fixed_advance_pc 0x09

   126 

   127 #define DW_LNE_end_sequence 0x01

   128 #define DW_LNE_set_address  0x02

   129 #define DW_LNE_define_file  0x03

   130 

   131 #define DW_CFA_advance_loc      0x01

   132 #define DW_CFA_offset           0x02

   133 #define DW_CFA_restore          0x03

   134 #define DW_CFA_set_loc          0x01

   135 #define DW_CFA_advance_loc1     0x02

   136 #define DW_CFA_advance_loc2     0x03

   137 #define DW_CFA_advance_loc4     0x04

   138 #define DW_CFA_offset_extended  0x05

   139 #define DW_CFA_restore_extended 0x06

   140 #define DW_CFA_undefined        0x07

   141 #define DW_CFA_same_value       0x08

   142 #define DW_CFA_register         0x09

   143 #define DW_CFA_remember_state   0x0a

   144 #define DW_CFA_restore_state    0x0b

   145 #define DW_CFA_def_cfa          0x0c

   146 #define DW_CFA_def_cfa_register 0x0d

   147 #define DW_CFA_def_cfa_offset   0x0e

   148 #define DW_CFA_nop              0x00

   149 

   150 #define CASE_TYPE_TAG \

   151 case DW_TAG_const_type: \

   152 case DW_TAG_volatile_type: \

   153 case DW_TAG_pointer_type: \

   154 case DW_TAG_base_type: \

   155 case DW_TAG_array_type: \

   156 case DW_TAG_structure_type: \

   157 case DW_TAG_union_type: \

   158 case DW_TAG_typedef: \

   159 case DW_TAG_subroutine_type: \

   160 case DW_TAG_enumeration_type: \

   161 case DW_TAG_enumerator: \

   162 case DW_TAG_reference_type

   163 

   164 struct ELFcie

   165 {

   166 	ELFcie *next;

   167 	u32     offset;

   168 	u8 *    augmentation;

   169 	u32     codeAlign;

   170 	s32     dataAlign;

   171 	int     returnAddress;

   172 	u8 *    data;

   173 	u32     dataLen;

   174 };

   175 

   176 struct ELFfde

   177 {

   178 	ELFcie *cie;

   179 	u32     address;

   180 	u32     end;

   181 	u8 *    data;

   182 	u32     dataLen;

   183 };

   184 

   185 enum ELFRegMode

   186 {

   187 	REG_NOT_SET,

   188 	REG_OFFSET,

   189 	REG_REGISTER

   190 };

   191 

   192 struct ELFFrameStateRegister

   193 {

   194 	ELFRegMode mode;

   195 	int        reg;

   196 	s32        offset;

   197 };

   198 

   199 struct ELFFrameStateRegisters

   200 {

   201 	ELFFrameStateRegister   regs[16];

   202 	ELFFrameStateRegisters *previous;

   203 };

   204 

   205 enum ELFCfaMode

   206 {

   207 	CFA_NOT_SET,

   208 	CFA_REG_OFFSET

   209 };

   210 

   211 struct ELFFrameState

   212 {

   213 	ELFFrameStateRegisters registers;

   214 

   215 	ELFCfaMode cfaMode;

   216 	int        cfaRegister;

   217 	s32        cfaOffset;

   218 

   219 	u32 pc;

   220 

   221 	int dataAlign;

   222 	int codeAlign;

   223 	int returnAddress;

   224 };

   225 

   226 extern bool8 cpuIsMultiBoot;

   227 

   228 Symbol *elfSymbols       = NULL;

   229 char *  elfSymbolsStrTab = NULL;

   230 int     elfSymbolsCount  = 0;

   231 

   232 ELFSectionHeader **elfSectionHeaders = NULL;

   233 char *elfSectionHeadersStringTable   = NULL;

   234 int   elfSectionHeadersCount         = 0;

   235 u8 *  elfFileData = NULL;

   236 

   237 CompileUnit *elfCompileUnits = NULL;

   238 DebugInfo *  elfDebugInfo    = NULL;

   239 char *       elfDebugStrings = NULL;

   240 

   241 ELFcie * elfCies     = NULL;

   242 ELFfde **elfFdes     = NULL;

   243 int      elfFdeCount = 0;

   244 

   245 CompileUnit *elfCurrentUnit = NULL;

   246 

   247 u32 elfRead4Bytes(u8 *);

   248 u16 elfRead2Bytes(u8 *);

   249 

   250 CompileUnit *elfGetCompileUnit(u32 addr)

   251 {

   252 	if (elfCompileUnits)

   253 	{

   254 		CompileUnit *unit = elfCompileUnits;

   255 		while (unit)

   256 		{

   257 			if (unit->lowPC)

   258 			{

   259 				if (addr >= unit->lowPC && addr < unit->highPC)

   260 					return unit;

   261 			}

   262 			else

   263 			{

   264 				ARanges *r = unit->ranges;

   265 				if (r)

   266 				{

   267 					int count = r->count;

   268 					for (int j = 0; j < count; j++)

   269 					{

   270 						if (addr >= r->ranges[j].lowPC && addr < r->ranges[j].highPC)

   271 							return unit;

   272 					}

   273 				}

   274 			}

   275 			unit = unit->next;

   276 		}

   277 	}

   278 	return NULL;

   279 }

   280 

   281 char *elfGetAddressSymbol(u32 addr)

   282 {

   283 	static char buffer[256];

   284 

   285 	CompileUnit *unit = elfGetCompileUnit(addr);

   286 	// found unit, need to find function

   287 	if (unit)

   288 	{

   289 		Function *func = unit->functions;

   290 		while (func)

   291 		{

   292 			if (addr >= func->lowPC && addr < func->highPC)

   293 			{

   294 				int   offset = addr - func->lowPC;

   295 				char *name   = func->name;

   296 				if (!name)

   297 					name = "";

   298 				if (offset)

   299 					sprintf(buffer, "%s+%d", name, offset);

   300 				else

   301 					strcpy(buffer, name);

   302 				return buffer;

   303 			}

   304 			func = func->next;

   305 		}

   306 	}

   307 

   308 	if (elfSymbolsCount)

   309 	{

   310 		for (int i = 0; i < elfSymbolsCount; i++)

   311 		{

   312 			Symbol *s = &elfSymbols[i];

   313 			if ((addr >= s->value)  && addr < (s->value+s->size))

   314 			{

   315 				int   offset = addr-s->value;

   316 				char *name   = s->name;

   317 				if (name == NULL)

   318 					name = "";

   319 				if (offset)

   320 					sprintf(buffer, "%s+%d", name, addr-s->value);

   321 				else

   322 					strcpy(buffer, name);

   323 				return buffer;

   324 			}

   325 			else if (addr == s->value)

   326 			{

   327 				if (s->name)

   328 					strcpy(buffer, s->name);

   329 				else

   330 					strcpy(buffer, "");

   331 				return buffer;

   332 			}

   333 		}

   334 	}

   335 

   336 	return "";

   337 }

   338 

   339 bool elfFindLineInModule(u32 *addr, char *name, int line)

   340 {

   341 	CompileUnit *unit = elfCompileUnits;

   342 

   343 	while (unit)

   344 	{

   345 		if (unit->lineInfoTable)

   346 		{

   347 			int   i;

   348 			int   count = unit->lineInfoTable->fileCount;

   349 			char *found = NULL;

   350 			for (i = 0; i < count; i++)

   351 			{

   352 				if (strcmp(name, unit->lineInfoTable->files[i]) == 0)

   353 				{

   354 					found = unit->lineInfoTable->files[i];

   355 					break;

   356 				}

   357 			}

   358 			// found a matching filename... try to find line now

   359 			if (found)

   360 			{

   361 				LineInfoItem *table = unit->lineInfoTable->lines;

   362 				count = unit->lineInfoTable->number;

   363 				for (i = 0; i < count; i++)

   364 				{

   365 					if (table[i].file == found && table[i].line == line)

   366 					{

   367 						*addr = table[i].address;

   368 						return true;

   369 					}

   370 				}

   371 				// we can only find a single match

   372 				return false;

   373 			}

   374 		}

   375 		unit = unit->next;

   376 	}

   377 	return false;

   378 }

   379 

   380 int elfFindLine(CompileUnit *unit, Function * /* func */, u32 addr, char **f)

   381 {

   382 	int currentLine = -1;

   383 	if (unit->hasLineInfo)

   384 	{

   385 		int count = unit->lineInfoTable->number;

   386 		LineInfoItem *table = unit->lineInfoTable->lines;

   387 		int i;

   388 		for (i = 0; i < count; i++)

   389 		{

   390 			if (addr <= table[i].address)

   391 				break;

   392 		}

   393 		if (i == count)

   394 			i--;

   395 		*f = table[i].file;

   396 		currentLine = table[i].line;

   397 	}

   398 	return currentLine;

   399 }

   400 

   401 bool elfFindLineInUnit(u32 *addr, CompileUnit *unit, int line)

   402 {

   403 	if (unit->hasLineInfo)

   404 	{

   405 		int count = unit->lineInfoTable->number;

   406 		LineInfoItem *table = unit->lineInfoTable->lines;

   407 		int i;

   408 		for (i = 0; i < count; i++)

   409 		{

   410 			if (line == table[i].line)

   411 			{

   412 				*addr = table[i].address;

   413 				return true;

   414 			}

   415 		}

   416 	}

   417 	return false;

   418 }

   419 

   420 bool elfGetCurrentFunction(u32 addr, Function **f, CompileUnit **u)

   421 {

   422 	CompileUnit *unit = elfGetCompileUnit(addr);

   423 	// found unit, need to find function

   424 	if (unit)

   425 	{

   426 		Function *func = unit->functions;

   427 		while (func)

   428 		{

   429 			if (addr >= func->lowPC && addr < func->highPC)

   430 			{

   431 				*f = func;

   432 				*u = unit;

   433 				return true;

   434 			}

   435 			func = func->next;

   436 		}

   437 	}

   438 	return false;

   439 }

   440 

   441 bool elfGetObject(char *name, Function *f, CompileUnit *u, Object **o)

   442 {

   443 	if (f && u)

   444 	{

   445 		Object *v = f->variables;

   446 

   447 		while (v)

   448 		{

   449 			if (strcmp(name, v->name) == 0)

   450 			{

   451 				*o = v;

   452 				return true;

   453 			}

   454 			v = v->next;

   455 		}

   456 		v = f->parameters;

   457 		while (v)

   458 		{

   459 			if (strcmp(name, v->name) == 0)

   460 			{

   461 				*o = v;

   462 				return true;

   463 			}

   464 			v = v->next;

   465 		}

   466 		v = u->variables;

   467 		while (v)

   468 		{

   469 			if (strcmp(name, v->name) == 0)

   470 			{

   471 				*o = v;

   472 				return true;

   473 			}

   474 			v = v->next;

   475 		}

   476 	}

   477 

   478 	CompileUnit *c = elfCompileUnits;

   479 

   480 	while (c)

   481 	{

   482 		if (c != u)

   483 		{

   484 			Object *v = c->variables;

   485 			while (v)

   486 			{

   487 				if (strcmp(name, v->name) == 0)

   488 				{

   489 					*o = v;

   490 					return true;

   491 				}

   492 				v = v->next;

   493 			}

   494 		}

   495 		c = c->next;

   496 	}

   497 

   498 	return false;

   499 }

   500 

   501 char *elfGetSymbol(int i, u32 *value, u32 *size, int *type)

   502 {

   503 	if (i < elfSymbolsCount)

   504 	{

   505 		Symbol *s = &elfSymbols[i];

   506 		*value = s->value;

   507 		*size  = s->size;

   508 		*type  = s->type;

   509 		return s->name;

   510 	}

   511 	return NULL;

   512 }

   513 

   514 bool elfGetSymbolAddress(char *sym, u32 *addr, u32 *size, int *type)

   515 {

   516 	if (elfSymbolsCount)

   517 	{

   518 		for (int i = 0; i < elfSymbolsCount; i++)

   519 		{

   520 			Symbol *s = &elfSymbols[i];

   521 			if (strcmp(sym, s->name) == 0)

   522 			{

   523 				*addr = s->value;

   524 				*size = s->size;

   525 				*type = s->type;

   526 				return true;

   527 			}

   528 		}

   529 	}

   530 	return false;

   531 }

   532 

   533 ELFfde *elfGetFde(u32 address)

   534 {

   535 	if (elfFdes)

   536 	{

   537 		int i;

   538 		for (i = 0; i < elfFdeCount; i++)

   539 		{

   540 			if (address >= elfFdes[i]->address &&

   541 			    address < elfFdes[i]->end)

   542 			{

   543 				return elfFdes[i];

   544 			}

   545 		}

   546 	}

   547 

   548 	return NULL;

   549 }

   550 

   551 void elfExecuteCFAInstructions(ELFFrameState *state, u8 *data, u32 len,

   552                                u32 pc)

   553 {

   554 	u8 *end = data + len;

   555 	int bytes;

   556 	int reg;

   557 	ELFFrameStateRegisters *fs;

   558 

   559 	while (data < end && state->pc < pc)

   560 	{

   561 		u8 op = *data++;

   562 

   563 		switch (op >> 6)

   564 		{

   565 		case DW_CFA_advance_loc:

   566 			state->pc += (op & 0x3f) * state->codeAlign;

   567 			break;

   568 		case DW_CFA_offset:

   569 			reg = op & 0x3f;

   570 			state->registers.regs[reg].mode   = REG_OFFSET;

   571 			state->registers.regs[reg].offset = state->dataAlign *

   572 			                                    (s32)elfReadLEB128(data, &bytes);

   573 			data += bytes;

   574 			break;

   575 		case DW_CFA_restore:

   576 			// we don't care much about the other possible settings,

   577 			// so just setting to unset is enough for now

   578 			state->registers.regs[op & 0x3f].mode = REG_NOT_SET;

   579 			break;

   580 		case 0:

   581 			switch (op & 0x3f)

   582 			{

   583 			case DW_CFA_nop:

   584 				break;

   585 			case DW_CFA_advance_loc1:

   586 				state->pc += state->codeAlign * (*data++);

   587 				break;

   588 			case DW_CFA_advance_loc2:

   589 				state->pc += state->codeAlign * elfRead2Bytes(data);

   590 				data      += 2;

   591 				break;

   592 			case DW_CFA_advance_loc4:

   593 				state->pc += state->codeAlign * elfRead4Bytes(data);

   594 				data      += 4;

   595 				break;

   596 			case DW_CFA_offset_extended:

   597 				reg   = elfReadLEB128(data, &bytes);

   598 				data += bytes;

   599 				state->registers.regs[reg].mode   = REG_OFFSET;

   600 				state->registers.regs[reg].offset = state->dataAlign *

   601 				                                    (s32)elfReadLEB128(data, &bytes);

   602 				data += bytes;

   603 				break;

   604 			case DW_CFA_restore_extended:

   605 			case DW_CFA_undefined:

   606 			case DW_CFA_same_value:

   607 				reg   = elfReadLEB128(data, &bytes);

   608 				data += bytes;

   609 				state->registers.regs[reg].mode = REG_NOT_SET;

   610 				break;

   611 			case DW_CFA_register:

   612 				reg   = elfReadLEB128(data, &bytes);

   613 				data += bytes;

   614 				state->registers.regs[reg].mode = REG_REGISTER;

   615 				state->registers.regs[reg].reg  = elfReadLEB128(data, &bytes);

   616 				data += bytes;

   617 				break;

   618 			case DW_CFA_remember_state:

   619 				fs = (ELFFrameStateRegisters *)calloc(1,

   620 				                                      sizeof(ELFFrameStateRegisters));

   621 				memcpy(fs, &state->registers, sizeof(ELFFrameStateRegisters));

   622 				state->registers.previous = fs;

   623 				break;

   624 			case DW_CFA_restore_state:

   625 				if (state->registers.previous == NULL)

   626 				{

   627 					printf("Error: previous frame state is NULL.\n");

   628 					return;

   629 				}

   630 				fs = state->registers.previous;

   631 				memcpy(&state->registers, fs, sizeof(ELFFrameStateRegisters));

   632 				free(fs);

   633 				break;

   634 			case DW_CFA_def_cfa:

   635 				state->cfaRegister = elfReadLEB128(data, &bytes);

   636 				data += bytes;

   637 				state->cfaOffset = (s32)elfReadLEB128(data, &bytes);

   638 				data += bytes;

   639 				state->cfaMode = CFA_REG_OFFSET;

   640 				break;

   641 			case DW_CFA_def_cfa_register:

   642 				state->cfaRegister = elfReadLEB128(data, &bytes);

   643 				data += bytes;

   644 				state->cfaMode = CFA_REG_OFFSET;

   645 				break;

   646 			case DW_CFA_def_cfa_offset:

   647 				state->cfaOffset = (s32)elfReadLEB128(data, &bytes);

   648 				data += bytes;

   649 				state->cfaMode = CFA_REG_OFFSET;

   650 				break;

   651 			default:

   652 				printf("Unknown CFA opcode %08x\n", op);

   653 				return;

   654 			}

   655 			break;

   656 		default:

   657 			printf("Unknown CFA opcode %08x\n", op);

   658 			return;

   659 		}

   660 	}

   661 }

   662 

   663 ELFFrameState *elfGetFrameState(ELFfde *fde, u32 address)

   664 {

   665 	ELFFrameState *state = (ELFFrameState *)calloc(1, sizeof(ELFFrameState));

   666 	state->pc            = fde->address;

   667 	state->dataAlign     = fde->cie->dataAlign;

   668 	state->codeAlign     = fde->cie->codeAlign;

   669 	state->returnAddress = fde->cie->returnAddress;

   670 

   671 	elfExecuteCFAInstructions(state,

   672 	                          fde->cie->data,

   673 	                          fde->cie->dataLen,

   674 	                          0xffffffff);

   675 	elfExecuteCFAInstructions(state,

   676 	                          fde->data,

   677 	                          fde->dataLen,

   678 	                          address);

   679 

   680 	return state;

   681 }

   682 

   683 void elfPrintCallChain(u32 address)

   684 {

   685 	int count = 1;

   686 

   687 	reg_pair regs[15];

   688 	reg_pair newRegs[15];

   689 

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

   691 

   692 	while (count < 20)

   693 	{

   694 		char *addr = elfGetAddressSymbol(address);

   695 		if (*addr == 0)

   696 			addr = "???";

   697 

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

   699 

   700 		ELFfde *fde = elfGetFde(address);

   701 

   702 		if (fde == NULL)

   703 		{

   704 			break;

   705 		}

   706 

   707 		ELFFrameState *state = elfGetFrameState(fde, address);

   708 

   709 		if (!state)

   710 		{

   711 			break;

   712 		}

   713 

   714 		if (state->cfaMode == CFA_REG_OFFSET)

   715 		{

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

   717 			u32 addr = 0;

   718 			for (int i = 0; i < 15; i++)

   719 			{

   720 				ELFFrameStateRegister *r = &state->registers.

   721 				                           regs[i];

   722 

   723 				switch (r->mode)

   724 				{

   725 				case REG_NOT_SET:

   726 					newRegs[i].I = regs[i].I;

   727 					break;

   728 				case REG_OFFSET:

   729 					newRegs[i].I = elfReadMemory(regs[state->cfaRegister].I +

   730 					                             state->cfaOffset +

   731 					                             r->offset);

   732 					break;

   733 				case REG_REGISTER:

   734 					newRegs[i].I = regs[r->reg].I;

   735 					break;

   736 				default:

   737 					printf("Unknown register mode: %d\n", r->mode);

   738 					break;

   739 				}

   740 			}

   741 			memcpy(regs, newRegs, sizeof(reg_pair)*15);

   742 			addr    = newRegs[14].I;

   743 			addr   &= 0xfffffffe;

   744 			address = addr;

   745 			count++;

   746 		}

   747 		else

   748 		{

   749 			printf("CFA not set\n");

   750 			break;

   751 		}

   752 		if (state->registers.previous)

   753 		{

   754 			ELFFrameStateRegisters *prev = state->registers.previous;

   755 

   756 			while (prev)

   757 			{

   758 				ELFFrameStateRegisters *p = prev->previous;

   759 				free(prev);

   760 				prev = p;

   761 			}

   762 		}

   763 		free(state);

   764 	}

   765 }

   766 

   767 u32 elfDecodeLocation(Function *f, ELFBlock *o, LocationType *type, u32 base)

   768 {

   769 	u32 framebase = 0;

   770 	if (f && f->frameBase)

   771 	{

   772 		ELFBlock *b = f->frameBase;

   773 		switch (*b->data)

   774 		{

   775 		case DW_OP_reg0:

   776 		case DW_OP_reg1:

   777 		case DW_OP_reg2:

   778 		case DW_OP_reg3:

   779 		case DW_OP_reg4:

   780 		case DW_OP_reg5:

   781 		case DW_OP_reg6:

   782 		case DW_OP_reg7:

   783 		case DW_OP_reg8:

   784 		case DW_OP_reg9:

   785 		case DW_OP_reg10:

   786 		case DW_OP_reg11:

   787 		case DW_OP_reg12:

   788 		case DW_OP_reg13:

   789 		case DW_OP_reg14:

   790 		case DW_OP_reg15:

   791 			framebase = reg[*b->data-0x50].I;

   792 			break;

   793 		default:

   794 			fprintf(stderr, "Unknown frameBase %02x\n", *b->data);

   795 			break;

   796 		}

   797 	}

   798 

   799 	ELFBlock *loc      = o;

   800 	u32       location = 0;

   801 	int       bytes    = 0;

   802 	if (loc)

   803 	{

   804 		switch (*loc->data)

   805 		{

   806 		case DW_OP_addr:

   807 			location = elfRead4Bytes(loc->data+1);

   808 			*type    = LOCATION_memory;

   809 			break;

   810 		case DW_OP_plus_uconst:

   811 			location = base + elfReadLEB128(loc->data+1, &bytes);

   812 			*type    = LOCATION_memory;

   813 			break;

   814 		case DW_OP_reg0:

   815 		case DW_OP_reg1:

   816 		case DW_OP_reg2:

   817 		case DW_OP_reg3:

   818 		case DW_OP_reg4:

   819 		case DW_OP_reg5:

   820 		case DW_OP_reg6:

   821 		case DW_OP_reg7:

   822 		case DW_OP_reg8:

   823 		case DW_OP_reg9:

   824 		case DW_OP_reg10:

   825 		case DW_OP_reg11:

   826 		case DW_OP_reg12:

   827 		case DW_OP_reg13:

   828 		case DW_OP_reg14:

   829 		case DW_OP_reg15:

   830 			location = *loc->data - 0x50;

   831 			*type    = LOCATION_register;

   832 			break;

   833 		case DW_OP_fbreg:

   834 		{

   835 			int bytes;

   836 			s32 off = elfReadSignedLEB128(loc->data+1, &bytes);

   837 			location = framebase + off;

   838 			*type    = LOCATION_memory;

   839 			break;

   840 		}

   841 		default:

   842 			fprintf(stderr, "Unknown location %02x\n", *loc->data);

   843 			break;

   844 		}

   845 	}

   846 	return location;

   847 }

   848 

   849 u32 elfDecodeLocation(Function *f, ELFBlock *o, LocationType *type)

   850 {

   851 	return elfDecodeLocation(f, o, type, 0);

   852 }

   853 

   854 // reading function

   855 

   856 u32 elfRead4Bytes(u8 *data)

   857 {

   858 	u32 value = *data++;

   859 	value |= (*data++ << 8);

   860 	value |= (*data++ << 16);

   861 	value |= (*data << 24);

   862 	return value;

   863 }

   864 

   865 u16 elfRead2Bytes(u8 *data)

   866 {

   867 	u16 value = *data++;

   868 	value |= (*data << 8);

   869 	return value;

   870 }

   871 

   872 char *elfReadString(u8 *data, int *bytesRead)

   873 {

   874 	if (*data == 0)

   875 	{

   876 		*bytesRead = 1;

   877 		return NULL;

   878 	}

   879 	*bytesRead = strlen((char *)data) + 1;

   880 	return (char *)data;

   881 }

   882 

   883 s32 elfReadSignedLEB128(u8 *data, int *bytesRead)

   884 {

   885 	s32 result = 0;

   886 	int shift  = 0;

   887 	int count  = 0;

   888 

   889 	u8 byte;

   890 	do

   891 	{

   892 		byte = *data++;

   893 		count++;

   894 		result |= (byte & 0x7f) << shift;

   895 		shift  += 7;

   896 	}

   897 	while (byte & 0x80);

   898 	if ((shift < 32) && (byte & 0x40))

   899 		result |= -(1 << shift);

   900 	*bytesRead = count;

   901 	return result;

   902 }

   903 

   904 u32 elfReadLEB128(u8 *data, int *bytesRead)

   905 {

   906 	u32 result = 0;

   907 	int shift  = 0;

   908 	int count  = 0;

   909 	u8  byte;

   910 	do

   911 	{

   912 		byte = *data++;

   913 		count++;

   914 		result |= (byte & 0x7f) << shift;

   915 		shift  += 7;

   916 	}

   917 	while (byte & 0x80);

   918 	*bytesRead = count;

   919 	return result;

   920 }

   921 

   922 u8 *elfReadSection(u8 *data, ELFSectionHeader *sh)

   923 {

   924 	return data + READ32LE(&sh->offset);

   925 }

   926 

   927 ELFSectionHeader *elfGetSectionByName(char *name)

   928 {

   929 	for (int i = 0; i < elfSectionHeadersCount; i++)

   930 	{

   931 		if (strcmp(name,

   932 		           &elfSectionHeadersStringTable[READ32LE(&elfSectionHeaders[i]->

   933 		                                                  name)]) == 0)

   934 		{

   935 			return elfSectionHeaders[i];

   936 		}

   937 	}

   938 	return NULL;

   939 }

   940 

   941 ELFSectionHeader *elfGetSectionByNumber(int number)

   942 {

   943 	if (number < elfSectionHeadersCount)

   944 	{

   945 		return elfSectionHeaders[number];

   946 	}

   947 	return NULL;

   948 }

   949 

   950 CompileUnit *elfGetCompileUnitForData(u8 *data)

   951 {

   952 	u8 *end = elfCurrentUnit->top + 4 + elfCurrentUnit->length;

   953 

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

   955 		return elfCurrentUnit;

   956 

   957 	CompileUnit *unit = elfCompileUnits;

   958 

   959 	while (unit)

   960 	{

   961 		end = unit->top + 4 + unit->length;

   962 

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

   964 			return unit;

   965 

   966 		unit = unit->next;

   967 	}

   968 

   969 	printf("Error: cannot find reference to compile unit at offset %08x\n",

   970 	       (int)(data - elfDebugInfo->infodata));

   971 	exit(-1);

   972 }

   973 

   974 u8 *elfReadAttribute(u8 *data, ELFAttr *attr)

   975 {

   976 	int bytes;

   977 	int form = attr->form;

   978 start:

   979 	switch (form)

   980 	{

   981 	case DW_FORM_addr:

   982 		attr->value = elfRead4Bytes(data);

   983 		data       += 4;

   984 		break;

   985 	case DW_FORM_data2:

   986 		attr->value = elfRead2Bytes(data);

   987 		data       += 2;

   988 		break;

   989 	case DW_FORM_data4:

   990 		attr->value = elfRead4Bytes(data);

   991 		data       += 4;

   992 		break;

   993 	case DW_FORM_string:

   994 		attr->string = (char *)data;

   995 		data        += strlen(attr->string)+1;

   996 		break;

   997 	case DW_FORM_strp:

   998 		attr->string = elfDebugStrings + elfRead4Bytes(data);

   999 		data        += 4;

  1000 		break;

  1001 	case DW_FORM_block:

  1002 		attr->block         = (ELFBlock *)malloc(sizeof(ELFBlock));

  1003 		attr->block->length = elfReadLEB128(data, &bytes);

  1004 		data += bytes;

  1005 		attr->block->data = data;

  1006 		data += attr->block->length;

  1007 		break;

  1008 	case DW_FORM_block1:

  1009 		attr->block         = (ELFBlock *)malloc(sizeof(ELFBlock));

  1010 		attr->block->length = *data++;

  1011 		attr->block->data   = data;

  1012 		data += attr->block->length;

  1013 		break;

  1014 	case DW_FORM_data1:

  1015 		attr->value = *data++;

  1016 		break;

  1017 	case DW_FORM_flag:

  1018 		attr->flag = (*data++) ? true : false;

  1019 		break;

  1020 	case DW_FORM_sdata:

  1021 		attr->value = elfReadSignedLEB128(data, &bytes);

  1022 		data       += bytes;

  1023 		break;

  1024 	case DW_FORM_udata:

  1025 		attr->value = elfReadLEB128(data, &bytes);

  1026 		data       += bytes;

  1027 		break;

  1028 	case DW_FORM_ref_addr:

  1029 		attr->value = (elfDebugInfo->infodata + elfRead4Bytes(data)) -

  1030 		              elfGetCompileUnitForData(data)->top;

  1031 		data += 4;

  1032 		break;

  1033 	case DW_FORM_ref4:

  1034 		attr->value = elfRead4Bytes(data);

  1035 		data       += 4;

  1036 		break;

  1037 	case DW_FORM_ref_udata:

  1038 		attr->value = (elfDebugInfo->infodata +

  1039 		               (elfGetCompileUnitForData(data)->top -

  1040 		                elfDebugInfo->infodata) +

  1041 		               elfReadLEB128(data, &bytes)) -

  1042 		              elfCurrentUnit->top;

  1043 		data += bytes;

  1044 		break;

  1045 	case DW_FORM_indirect:

  1046 		form  = elfReadLEB128(data, &bytes);

  1047 		data += bytes;

  1048 		goto start;

  1049 	default:

  1050 		fprintf(stderr, "Unsupported FORM %02x\n", form);

  1051 		exit(-1);

  1052 	}

  1053 	return data;

  1054 }

  1055 

  1056 ELFAbbrev *elfGetAbbrev(ELFAbbrev **table, u32 number)

  1057 {

  1058 	int hash = number % 121;

  1059 

  1060 	ELFAbbrev *abbrev = table[hash];

  1061 

  1062 	while (abbrev)

  1063 	{

  1064 		if (abbrev->number == number)

  1065 			return abbrev;

  1066 		abbrev = abbrev->next;

  1067 	}

  1068 	return NULL;

  1069 }

  1070 

  1071 ELFAbbrev * *elfReadAbbrevs(u8 *data, u32 offset)

  1072 {

  1073 	data += offset;

  1074 	ELFAbbrev **abbrevs = (ELFAbbrev * *)calloc(sizeof(ELFAbbrev *)*121, 1);

  1075 	int         bytes   = 0;

  1076 	u32         number  = elfReadLEB128(data, &bytes);

  1077 	data += bytes;

  1078 	while (number)

  1079 	{

  1080 		ELFAbbrev *abbrev = (ELFAbbrev *)calloc(sizeof(ELFAbbrev), 1);

  1081 

  1082 		// read tag information

  1083 		abbrev->number = number;

  1084 		abbrev->tag    = elfReadLEB128(data, &bytes);

  1085 		data += bytes;

  1086 		abbrev->hasChildren = *data++ ? true : false;

  1087 

  1088 		// read attributes

  1089 		int name = elfReadLEB128(data, &bytes);

  1090 		data += bytes;

  1091 		int form = elfReadLEB128(data, &bytes);

  1092 		data += bytes;

  1093 

  1094 		while (name)

  1095 		{

  1096 			if ((abbrev->numAttrs % 4) == 0)

  1097 			{

  1098 				abbrev->attrs = (ELFAttr *)realloc(abbrev->attrs,

  1099 				                                   (abbrev->numAttrs + 4) *

  1100 				                                   sizeof(ELFAttr));

  1101 			}

  1102 			abbrev->attrs[abbrev->numAttrs].name   = name;

  1103 			abbrev->attrs[abbrev->numAttrs++].form = form;

  1104 

  1105 			name  = elfReadLEB128(data, &bytes);

  1106 			data += bytes;

  1107 			form  = elfReadLEB128(data, &bytes);

  1108 			data += bytes;

  1109 		}

  1110 

  1111 		int hash = number % 121;

  1112 		abbrev->next  = abbrevs[hash];

  1113 		abbrevs[hash] = abbrev;

  1114 

  1115 		number = elfReadLEB128(data, &bytes);

  1116 		data  += bytes;

  1117 

  1118 		if (elfGetAbbrev(abbrevs, number) != NULL)

  1119 			break;

  1120 	}

  1121 

  1122 	return abbrevs;

  1123 }

  1124 

  1125 void elfParseCFA(u8 *top)

  1126 {

  1127 	ELFSectionHeader *h = elfGetSectionByName(".debug_frame");

  1128 

  1129 	if (h == NULL)

  1130 	{

  1131 		return;

  1132 	}

  1133 

  1134 	u8 *data = elfReadSection(top, h);

  1135 

  1136 	u8 *topOffset = data;

  1137 

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

  1139 

  1140 	ELFcie *cies = NULL;

  1141 

  1142 	while (data < end)

  1143 	{

  1144 		u32 offset = data - topOffset;

  1145 		u32 len    = elfRead4Bytes(data);

  1146 		data += 4;

  1147 

  1148 		u8 *dataEnd = data + len;

  1149 

  1150 		u32 id = elfRead4Bytes(data);

  1151 		data += 4;

  1152 

  1153 		if (id == 0xffffffff)

  1154 		{

  1155 			// skip version

  1156 			*data++;

  1157 

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

  1159 

  1160 			cie->next = cies;

  1161 			cies      = cie;

  1162 

  1163 			cie->offset = offset;

  1164 

  1165 			cie->augmentation = data;

  1166 			while (*data)

  1167 				data++;

  1168 			data++;

  1169 

  1170 			if (*cie->augmentation)

  1171 			{

  1172 				fprintf(stderr, "Error: augmentation not supported\n");

  1173 				exit(-1);

  1174 			}

  1175 

  1176 			int bytes;

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

  1178 			data += bytes;

  1179 

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

  1181 			data += bytes;

  1182 

  1183 			cie->returnAddress = *data++;

  1184 

  1185 			cie->data    = data;

  1186 			cie->dataLen = dataEnd - data;

  1187 		}

  1188 		else

  1189 		{

  1190 			ELFfde *fde = (ELFfde *)calloc(1, sizeof(ELFfde));

  1191 

  1192 			ELFcie *cie = cies;

  1193 

  1194 			while (cie != NULL)

  1195 			{

  1196 				if (cie->offset == id)

  1197 					break;

  1198 				cie = cie->next;

  1199 			}

  1200 

  1201 			if (!cie)

  1202 			{

  1203 				fprintf(stderr, "Cannot find CIE %08x\n", id);

  1204 				exit(-1);

  1205 			}

  1206 

  1207 			fde->cie = cie;

  1208 

  1209 			fde->address = elfRead4Bytes(data);

  1210 			data        += 4;

  1211 

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

  1213 			data    += 4;

  1214 

  1215 			fde->data    = data;

  1216 			fde->dataLen = dataEnd - data;

  1217 

  1218 			if ((elfFdeCount %10) == 0)

  1219 			{

  1220 				elfFdes = (ELFfde * *)realloc(elfFdes, (elfFdeCount+10) *

  1221 				                              sizeof(ELFfde *));

  1222 			}

  1223 			elfFdes[elfFdeCount++] = fde;

  1224 		}

  1225 		data = dataEnd;

  1226 	}

  1227 

  1228 	elfCies = cies;

  1229 }

  1230 

  1231 void elfAddLine(LineInfo *l, u32 a, int file, int line, int *max)

  1232 {

  1233 	if (l->number == *max)

  1234 	{

  1235 		*max    += 1000;

  1236 		l->lines = (LineInfoItem *)realloc(l->lines, *max*sizeof(LineInfoItem));

  1237 	}

  1238 	LineInfoItem *li = &l->lines[l->number];

  1239 	li->file    = l->files[file-1];

  1240 	li->address = a;

  1241 	li->line    = line;

  1242 	l->number++;

  1243 }

  1244 

  1245 void elfParseLineInfo(CompileUnit *unit, u8 *top)

  1246 {

  1247 	ELFSectionHeader *h = elfGetSectionByName(".debug_line");

  1248 	if (h == NULL)

  1249 	{

  1250 		fprintf(stderr, "No line information found\n");

  1251 		return;

  1252 	}

  1253 	LineInfo *l = unit->lineInfoTable = (LineInfo *)calloc(1, sizeof(LineInfo));

  1254 	l->number = 0;

  1255 	int max = 1000;

  1256 	l->lines = (LineInfoItem *)malloc(1000*sizeof(LineInfoItem));

  1257 

  1258 	u8 *data = elfReadSection(top, h);

  1259 	data += unit->lineInfo;

  1260 	u32 totalLen = elfRead4Bytes(data);

  1261 	data += 4;

  1262 	u8 *end = data + totalLen;

  1263 	//  u16 version = elfRead2Bytes(data);

  1264 	data += 2;

  1265 	//  u32 offset = elfRead4Bytes(data);

  1266 	data += 4;

  1267 	int minInstrSize  = *data++;

  1268 	int defaultIsStmt = *data++;

  1269 	int lineBase      = (s8)*data++;

  1270 	int lineRange     = *data++;

  1271 	int opcodeBase    = *data++;

  1272 	u8 *stdOpLen      = (u8 *)malloc(opcodeBase * sizeof(u8));

  1273 	stdOpLen[0] = 1;

  1274 	int i;

  1275 	for (i = 1; i < opcodeBase; i++)

  1276 		stdOpLen[i] = *data++;

  1277 

  1278 	free(stdOpLen); // todo

  1279 	int bytes = 0;

  1280 

  1281 	char *s;

  1282 	while ((s = elfReadString(data, &bytes)) != NULL)

  1283 	{

  1284 		data += bytes;

  1285 		//    fprintf(stderr, "Directory is %s\n", s);

  1286 	}

  1287 	data += bytes;

  1288 	int count = 4;

  1289 	int index = 0;

  1290 	l->files = (char * *)malloc(sizeof(char *)*count);

  1291 

  1292 	while ((s = elfReadString(data, &bytes)) != NULL)

  1293 	{

  1294 		l->files[index++] = s;

  1295 

  1296 		data += bytes;

  1297 		// directory

  1298 		elfReadLEB128(data, &bytes);

  1299 		data += bytes;

  1300 		// time

  1301 		elfReadLEB128(data, &bytes);

  1302 		data += bytes;

  1303 		// size

  1304 		elfReadLEB128(data, &bytes);

  1305 		data += bytes;

  1306 		//    fprintf(stderr, "File is %s\n", s);

  1307 		if (index == count)

  1308 		{

  1309 			count   += 4;

  1310 			l->files = (char * *)realloc(l->files, sizeof(char *)*count);

  1311 		}

  1312 	}

  1313 	l->fileCount = index;

  1314 	data        += bytes;

  1315 

  1316 	while (data < end)

  1317 	{

  1318 		u32 address    = 0;

  1319 		int file       = 1;

  1320 		int line       = 1;

  1321 		int col        = 0;

  1322 		int isStmt     = defaultIsStmt;

  1323 		int basicBlock = 0;

  1324 		int endSeq     = 0;

  1325 

  1326 		while (!endSeq)

  1327 		{

  1328 			int op = *data++;

  1329 			switch (op)

  1330 			{

  1331 			case DW_LNS_extended_op:

  1332 			{

  1333 				data++;

  1334 				op = *data++;

  1335 				switch (op)

  1336 				{

  1337 				case DW_LNE_end_sequence:

  1338 					endSeq = 1;

  1339 					break;

  1340 				case DW_LNE_set_address:

  1341 					address = elfRead4Bytes(data);

  1342 					data   += 4;

  1343 					break;

  1344 				default:

  1345 					fprintf(stderr, "Unknown extended LINE opcode %02x\n", op);

  1346 					exit(-1);

  1347 				}

  1348 				break;

  1349 			}

  1350 			case DW_LNS_copy:

  1351 				//      fprintf(stderr, "Address %08x line %d (%d)\n", address, line, file);

  1352 				elfAddLine(l, address, file, line, &max);

  1353 				basicBlock = 0;

  1354 				break;

  1355 			case DW_LNS_advance_pc:

  1356 				address += minInstrSize * elfReadLEB128(data, &bytes);

  1357 				data    += bytes;

  1358 				break;

  1359 			case DW_LNS_advance_line:

  1360 				line += elfReadSignedLEB128(data, &bytes);

  1361 				data += bytes;

  1362 				break;

  1363 			case DW_LNS_set_file:

  1364 				file  = elfReadLEB128(data, &bytes);

  1365 				data += bytes;

  1366 				break;

  1367 			case DW_LNS_set_column:

  1368 				col   = elfReadLEB128(data, &bytes);

  1369 				data += bytes;

  1370 				break;

  1371 			case DW_LNS_negate_stmt:

  1372 				isStmt = !isStmt;

  1373 				break;

  1374 			case DW_LNS_set_basic_block:

  1375 				basicBlock = 1;

  1376 				break;

  1377 			case DW_LNS_const_add_pc:

  1378 				address += (minInstrSize *((255 - opcodeBase)/lineRange));

  1379 				break;

  1380 			case DW_LNS_fixed_advance_pc:

  1381 				address += elfRead2Bytes(data);

  1382 				data    += 2;

  1383 				break;

  1384 			default:

  1385 				op       = op - opcodeBase;

  1386 				address += (op / lineRange) * minInstrSize;

  1387 				line    += lineBase + (op % lineRange);

  1388 				elfAddLine(l, address, file, line, &max);

  1389 				//        fprintf(stderr, "Address %08x line %d (%d)\n", address, line,file);

  1390 				basicBlock = 1;

  1391 				break;

  1392 			}

  1393 		}

  1394 	}

  1395 	l->lines = (LineInfoItem *)realloc(l->lines, l->number*sizeof(LineInfoItem));

  1396 }

  1397 

  1398 u8 *elfSkipData(u8 *data, ELFAbbrev *abbrev, ELFAbbrev **abbrevs)

  1399 {

  1400 	int i;

  1401 	int bytes;

  1402 

  1403 	for (i = 0; i < abbrev->numAttrs; i++)

  1404 	{

  1405 		data = elfReadAttribute(data,  &abbrev->attrs[i]);

  1406 		if (abbrev->attrs[i].form == DW_FORM_block1)

  1407 			free(abbrev->attrs[i].block);

  1408 	}

  1409 

  1410 	if (abbrev->hasChildren)

  1411 	{

  1412 		int nesting = 1;

  1413 		while (nesting)

  1414 		{

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

  1416 			data += bytes;

  1417 

  1418 			if (!abbrevNum)

  1419 			{

  1420 				nesting--;

  1421 				continue;

  1422 			}

  1423 

  1424 			abbrev = elfGetAbbrev(abbrevs, abbrevNum);

  1425 

  1426 			for (i = 0; i < abbrev->numAttrs; i++)

  1427 			{

  1428 				data = elfReadAttribute(data,  &abbrev->attrs[i]);

  1429 				if (abbrev->attrs[i].form == DW_FORM_block1)

  1430 					free(abbrev->attrs[i].block);

  1431 			}

  1432 

  1433 			if (abbrev->hasChildren)

  1434 			{

  1435 				nesting++;

  1436 			}

  1437 		}

  1438 	}

  1439 	return data;

  1440 }

  1441 

  1442 Type *elfParseType(CompileUnit *unit, u32);

  1443 u8 *elfParseObject(u8 *data, ELFAbbrev *abbrev, CompileUnit *unit,

  1444                    Object **object);

  1445 u8 *elfParseFunction(u8 *data, ELFAbbrev *abbrev, CompileUnit *unit,

  1446                      Function **function);

  1447 void elfCleanUp(Function *);

  1448 

  1449 void elfAddType(Type *type, CompileUnit *unit, u32 offset)

  1450 {

  1451 	if (type->next == NULL)

  1452 	{

  1453 		if (unit->types != type && type->offset == 0)

  1454 		{

  1455 			type->offset = offset;

  1456 			type->next   = unit->types;

  1457 			unit->types  = type;

  1458 		}

  1459 	}

  1460 }

  1461 

  1462 void elfParseType(u8 *data, u32 offset, ELFAbbrev *abbrev, CompileUnit *unit,

  1463                   Type **type)

  1464 {

  1465 	switch (abbrev->tag)

  1466 	{

  1467 	case DW_TAG_typedef:

  1468 	{

  1469 		u32   typeref = 0;

  1470 		char *name    = NULL;

  1471 		for (int i = 0; i < abbrev->numAttrs; i++)

  1472 		{

  1473 			ELFAttr *attr = &abbrev->attrs[i];

  1474 			data = elfReadAttribute(data, attr);

  1475 			switch (attr->name)

  1476 			{

  1477 			case DW_AT_name:

  1478 				name = attr->string;

  1479 				break;

  1480 			case DW_AT_type:

  1481 				typeref = attr->value;

  1482 				break;

  1483 			case DW_AT_decl_file:

  1484 			case DW_AT_decl_line:

  1485 				break;

  1486 			default:

  1487 				fprintf(stderr, "Unknown attribute for typedef %02x\n", attr->name);

  1488 				break;

  1489 			}

  1490 		}

  1491 		if (abbrev->hasChildren)

  1492 			fprintf(stderr, "Unexpected children for typedef\n");

  1493 		*type = elfParseType(unit, typeref);

  1494 		if (name)

  1495 			(*type)->name = name;

  1496 		return;

  1497 		break;

  1498 	}

  1499 	case DW_TAG_union_type:

  1500 	case DW_TAG_structure_type:

  1501 	{

  1502 		Type *t = (Type *)calloc(sizeof(Type), 1);

  1503 		if (abbrev->tag == DW_TAG_structure_type)

  1504 			t->type = TYPE_struct;

  1505 		else

  1506 			t->type = TYPE_union;

  1507 

  1508 		Struct *s = (Struct *)calloc(sizeof(Struct), 1);

  1509 		t->structure = s;

  1510 		elfAddType(t, unit, offset);

  1511 

  1512 		for (int i = 0; i < abbrev->numAttrs; i++)

  1513 		{

  1514 			ELFAttr *attr = &abbrev->attrs[i];

  1515 			data = elfReadAttribute(data, attr);

  1516 			switch (attr->name)

  1517 			{

  1518 			case DW_AT_name:

  1519 				t->name = attr->string;

  1520 				break;

  1521 			case DW_AT_byte_size:

  1522 				t->size = attr->value;

  1523 				break;

  1524 			case DW_AT_decl_file:

  1525 			case DW_AT_decl_line:

  1526 			case DW_AT_sibling:

  1527 			case DW_AT_containing_type: // todo?

  1528 			case DW_AT_declaration:

  1529 			case DW_AT_specification: // TODO:

  1530 				break;

  1531 			default:

  1532 				fprintf(stderr, "Unknown attribute for struct %02x\n", attr->name);

  1533 				break;

  1534 			}

  1535 		}

  1536 		if (abbrev->hasChildren)

  1537 		{

  1538 			int bytes;

  1539 			u32 num = elfReadLEB128(data, &bytes);

  1540 			data += bytes;

  1541 			int index = 0;

  1542 			while (num)

  1543 			{

  1544 				ELFAbbrev *abbr = elfGetAbbrev(unit->abbrevs, num);

  1545 

  1546 				switch (abbr->tag)

  1547 				{

  1548 				case DW_TAG_member:

  1549 				{

  1550 					if ((index % 4) == 0)

  1551 						s->members = (Member *)realloc(s->members,

  1552 						                               sizeof(Member)*(index+4));

  1553 					Member *m = &s->members[index];

  1554 					m->location  = NULL;

  1555 					m->bitOffset = 0;

  1556 					m->bitSize   = 0;

  1557 					m->byteSize  = 0;

  1558 					for (int i = 0; i < abbr->numAttrs; i++)

  1559 					{

  1560 						ELFAttr *attr = &abbr->attrs[i];

  1561 						data = elfReadAttribute(data, attr);

  1562 						switch (attr->name)

  1563 						{

  1564 						case DW_AT_name:

  1565 							m->name = attr->string;

  1566 							break;

  1567 						case DW_AT_type:

  1568 							m->type = elfParseType(unit, attr->value);

  1569 							break;

  1570 						case DW_AT_data_member_location:

  1571 							m->location = attr->block;

  1572 							break;

  1573 						case DW_AT_byte_size:

  1574 							m->byteSize = attr->value;

  1575 							break;

  1576 						case DW_AT_bit_offset:

  1577 							m->bitOffset = attr->value;

  1578 							break;

  1579 						case DW_AT_bit_size:

  1580 							m->bitSize = attr->value;

  1581 							break;

  1582 						case DW_AT_decl_file:

  1583 						case DW_AT_decl_line:

  1584 						case DW_AT_accessibility:

  1585 						case DW_AT_artificial: // todo?

  1586 							break;

  1587 						default:

  1588 							fprintf(stderr, "Unknown member attribute %02x\n",

  1589 							        attr->name);

  1590 						}

  1591 					}

  1592 					index++;

  1593 					break;

  1594 				}

  1595 				case DW_TAG_subprogram:

  1596 				{

  1597 					Function *fnc = NULL;

  1598 					data = elfParseFunction(data, abbr, unit, &fnc);

  1599 					if (fnc != NULL)

  1600 					{

  1601 						if (unit->lastFunction)

  1602 							unit->lastFunction->next = fnc;

  1603 						else

  1604 							unit->functions = fnc;

  1605 						unit->lastFunction = fnc;

  1606 					}

  1607 					break;

  1608 				}

  1609 				case DW_TAG_inheritance:

  1610 					// TODO: add support

  1611 					data = elfSkipData(data, abbr, unit->abbrevs);

  1612 					break;

  1613 CASE_TYPE_TAG:

  1614 					// skip types... parsed only when used

  1615 					data = elfSkipData(data, abbr, unit->abbrevs);

  1616 					break;

  1617 				case DW_TAG_variable:

  1618 					data = elfSkipData(data, abbr, unit->abbrevs);

  1619 					break;

  1620 				default:

  1621 					fprintf(stderr, "Unknown struct tag %02x %s\n", abbr->tag, t->name);

  1622 					data = elfSkipData(data, abbr, unit->abbrevs);

  1623 					break;

  1624 				}

  1625 				num   = elfReadLEB128(data, &bytes);

  1626 				data += bytes;

  1627 			}

  1628 			s->memberCount = index;

  1629 		}

  1630 		*type = t;

  1631 		return;

  1632 		break;

  1633 	}

  1634 	case DW_TAG_base_type:

  1635 	{

  1636 		Type *t = (Type *)calloc(sizeof(Type), 1);

  1637 

  1638 		t->type = TYPE_base;

  1639 		elfAddType(t, unit, offset);

  1640 		for (int i = 0; i < abbrev->numAttrs; i++)

  1641 		{

  1642 			ELFAttr *attr = &abbrev->attrs[i];

  1643 			data = elfReadAttribute(data, attr);

  1644 			switch (attr->name)

  1645 			{

  1646 			case DW_AT_name:

  1647 				t->name = attr->string;

  1648 				break;

  1649 			case DW_AT_encoding:

  1650 				t->encoding = attr->value;

  1651 				break;

  1652 			case DW_AT_byte_size:

  1653 				t->size = attr->value;

  1654 				break;

  1655 			case DW_AT_bit_size:

  1656 				t->bitSize = attr->value;

  1657 				break;

  1658 			default:

  1659 				fprintf(stderr, "Unknown attribute for base type %02x\n",

  1660 				        attr->name);

  1661 				break;

  1662 			}

  1663 		}

  1664 		if (abbrev->hasChildren)

  1665 			fprintf(stderr, "Unexpected children for base type\n");

  1666 		*type = t;

  1667 		return;

  1668 		break;

  1669 	}

  1670 	case DW_TAG_pointer_type:

  1671 	{

  1672 		Type *t = (Type *)calloc(sizeof(Type), 1);

  1673 

  1674 		t->type = TYPE_pointer;

  1675 

  1676 		elfAddType(t, unit, offset);

  1677 

  1678 		for (int i = 0; i < abbrev->numAttrs; i++)

  1679 		{

  1680 			ELFAttr *attr = &abbrev->attrs[i];

  1681 			data = elfReadAttribute(data, attr);

  1682 			switch (attr->name)

  1683 			{

  1684 			case DW_AT_type:

  1685 				t->pointer = elfParseType(unit, attr->value);

  1686 				break;

  1687 			case DW_AT_byte_size:

  1688 				t->size = attr->value;

  1689 				break;

  1690 			default:

  1691 				fprintf(stderr, "Unknown pointer type attribute %02x\n", attr->name);

  1692 				break;

  1693 			}

  1694 		}

  1695 		if (abbrev->hasChildren)

  1696 			fprintf(stderr, "Unexpected children for pointer type\n");

  1697 		*type = t;

  1698 		return;

  1699 		break;

  1700 	}

  1701 	case DW_TAG_reference_type:

  1702 	{

  1703 		Type *t = (Type *)calloc(sizeof(Type), 1);

  1704 

  1705 		t->type = TYPE_reference;

  1706 

  1707 		elfAddType(t, unit, offset);

  1708 

  1709 		for (int i = 0; i < abbrev->numAttrs; i++)

  1710 		{

  1711 			ELFAttr *attr = &abbrev->attrs[i];

  1712 			data = elfReadAttribute(data, attr);

  1713 			switch (attr->name)

  1714 			{

  1715 			case DW_AT_type:

  1716 				t->pointer = elfParseType(unit, attr->value);

  1717 				break;

  1718 			case DW_AT_byte_size:

  1719 				t->size = attr->value;

  1720 				break;

  1721 			default:

  1722 				fprintf(stderr, "Unknown ref type attribute %02x\n", attr->name);

  1723 				break;

  1724 			}

  1725 		}

  1726 		if (abbrev->hasChildren)

  1727 			fprintf(stderr, "Unexpected children for ref type\n");

  1728 		*type = t;

  1729 		return;

  1730 		break;

  1731 	}

  1732 	case DW_TAG_volatile_type:

  1733 	{

  1734 		u32 typeref = 0;

  1735 

  1736 		for (int i = 0; i < abbrev->numAttrs; i++)

  1737 		{

  1738 			ELFAttr *attr = &abbrev->attrs[i];

  1739 			data = elfReadAttribute(data, attr);

  1740 			switch (attr->name)

  1741 			{

  1742 			case DW_AT_type:

  1743 				typeref = attr->value;

  1744 				break;

  1745 			default:

  1746 				fprintf(stderr, "Unknown volatile attribute for type %02x\n",

  1747 				        attr->name);

  1748 				break;

  1749 			}

  1750 		}

  1751 		if (abbrev->hasChildren)

  1752 			fprintf(stderr, "Unexpected children for volatile type\n");

  1753 		*type = elfParseType(unit, typeref);

  1754 		return;

  1755 		break;

  1756 	}

  1757 	case DW_TAG_const_type:

  1758 	{

  1759 		u32 typeref = 0;

  1760 

  1761 		for (int i = 0; i < abbrev->numAttrs; i++)

  1762 		{

  1763 			ELFAttr *attr = &abbrev->attrs[i];

  1764 			data = elfReadAttribute(data, attr);

  1765 			switch (attr->name)

  1766 			{

  1767 			case DW_AT_type:

  1768 				typeref = attr->value;

  1769 				break;

  1770 			default:

  1771 				fprintf(stderr, "Unknown const attribute for type %02x\n",

  1772 				        attr->name);

  1773 				break;

  1774 			}

  1775 		}

  1776 		if (abbrev->hasChildren)

  1777 			fprintf(stderr, "Unexpected children for const type\n");

  1778 		*type = elfParseType(unit, typeref);

  1779 		return;

  1780 		break;

  1781 	}

  1782 	case DW_TAG_enumeration_type:

  1783 	{

  1784 		Type *t = (Type *)calloc(sizeof(Type), 1);

  1785 		t->type = TYPE_enum;

  1786 		Enum *e = (Enum *)calloc(sizeof(Enum), 1);

  1787 		t->enumeration = e;

  1788 		elfAddType(t, unit, offset);

  1789 		int count = 0;

  1790 		for (int i = 0; i < abbrev->numAttrs; i++)

  1791 		{

  1792 			ELFAttr *attr = &abbrev->attrs[i];

  1793 			data = elfReadAttribute(data, attr);

  1794 			switch (attr->name)

  1795 			{

  1796 			case DW_AT_name:

  1797 				t->name = attr->string;

  1798 				break;

  1799 			case DW_AT_byte_size:

  1800 				t->size = attr->value;

  1801 				break;

  1802 			case DW_AT_sibling:

  1803 			case DW_AT_decl_file:

  1804 			case DW_AT_decl_line:

  1805 				break;

  1806 			default:

  1807 				fprintf(stderr, "Unknown enum attribute %02x\n", attr->name);

  1808 			}

  1809 		}

  1810 		if (abbrev->hasChildren)

  1811 		{

  1812 			int bytes;

  1813 			u32 num = elfReadLEB128(data, &bytes);

  1814 			data += bytes;

  1815 			while (num)

  1816 			{

  1817 				ELFAbbrev *abbr = elfGetAbbrev(unit->abbrevs, num);

  1818 

  1819 				switch (abbr->tag)

  1820 				{

  1821 				case DW_TAG_enumerator:

  1822 				{

  1823 					count++;

  1824 					e->members = (EnumMember *)realloc(e->members,

  1825 					                                   count*sizeof(EnumMember));

  1826 					EnumMember *m = &e->members[count-1];

  1827 					for (int i = 0; i < abbr->numAttrs; i++)

  1828 					{

  1829 						ELFAttr *attr = &abbr->attrs[i];

  1830 						data = elfReadAttribute(data, attr);

  1831 						switch (attr->name)

  1832 						{

  1833 						case DW_AT_name:

  1834 							m->name = attr->string;

  1835 							break;

  1836 						case DW_AT_const_value:

  1837 							m->value = attr->value;

  1838 							break;

  1839 						default:

  1840 							fprintf(stderr, "Unknown sub param attribute %02x\n",

  1841 							        attr->name);

  1842 						}

  1843 					}

  1844 					break;

  1845 				}

  1846 				default:

  1847 					fprintf(stderr, "Unknown enum tag %02x\n", abbr->tag);

  1848 					data = elfSkipData(data, abbr, unit->abbrevs);

  1849 					break;

  1850 				}

  1851 				num   = elfReadLEB128(data, &bytes);

  1852 				data += bytes;

  1853 			}

  1854 		}

  1855 		e->count = count;

  1856 		*type    = t;

  1857 		return;

  1858 		break;

  1859 	}

  1860 	case DW_TAG_subroutine_type:

  1861 	{

  1862 		Type *t = (Type *)calloc(sizeof(Type), 1);

  1863 		t->type = TYPE_function;

  1864 		FunctionType *f = (FunctionType *)calloc(sizeof(FunctionType), 1);

  1865 		t->function = f;

  1866 		elfAddType(t, unit, offset);

  1867 		for (int i = 0; i < abbrev->numAttrs; i++)

  1868 		{

  1869 			ELFAttr *attr = &abbrev->attrs[i];

  1870 			data = elfReadAttribute(data, attr);

  1871 			switch (attr->name)

  1872 			{

  1873 			case DW_AT_prototyped:

  1874 			case DW_AT_sibling:

  1875 				break;

  1876 			case DW_AT_type:

  1877 				f->returnType = elfParseType(unit, attr->value);

  1878 				break;

  1879 			default:

  1880 				fprintf(stderr, "Unknown subroutine attribute %02x\n", attr->name);

  1881 			}

  1882 		}

  1883 		if (abbrev->hasChildren)

  1884 		{

  1885 			int bytes;

  1886 			u32 num = elfReadLEB128(data, &bytes);

  1887 			data += bytes;

  1888 			Object *lastVar = NULL;

  1889 			while (num)

  1890 			{

  1891 				ELFAbbrev *abbr = elfGetAbbrev(unit->abbrevs, num);

  1892 

  1893 				switch (abbr->tag)

  1894 				{

  1895 				case DW_TAG_formal_parameter:

  1896 				{

  1897 					Object *o;

  1898 					data = elfParseObject(data, abbr, unit, &o);

  1899 					if (f->args)

  1900 						lastVar->next = o;

  1901 					else

  1902 						f->args = o;

  1903 					lastVar = o;

  1904 					break;

  1905 				}

  1906 				case DW_TAG_unspecified_parameters:

  1907 					// no use in the debugger yet

  1908 					data = elfSkipData(data, abbr, unit->abbrevs);

  1909 					break;

  1910 CASE_TYPE_TAG:

  1911 					// skip types... parsed only when used

  1912 					data = elfSkipData(data, abbr, unit->abbrevs);

  1913 					break;

  1914 				default:

  1915 					fprintf(stderr, "Unknown subroutine tag %02x\n", abbr->tag);

  1916 					data = elfSkipData(data, abbr, unit->abbrevs);

  1917 					break;

  1918 				}

  1919 				num   = elfReadLEB128(data, &bytes);

  1920 				data += bytes;

  1921 			}

  1922 		}

  1923 		*type = t;

  1924 		return;

  1925 		break;

  1926 	}

  1927 	case DW_TAG_array_type:

  1928 	{

  1929 		u32    typeref = 0;

  1930 		int    i;

  1931 		Array *array = (Array *)calloc(sizeof(Array), 1);

  1932 		Type * t     = (Type *)calloc(sizeof(Type), 1);

  1933 		t->type = TYPE_array;

  1934 		elfAddType(t, unit, offset);

  1935 

  1936 		for (i = 0; i < abbrev->numAttrs; i++)

  1937 		{

  1938 			ELFAttr *attr = &abbrev->attrs[i];

  1939 			data = elfReadAttribute(data, attr);

  1940 			switch (attr->name)

  1941 			{

  1942 			case DW_AT_sibling:

  1943 				break;

  1944 			case DW_AT_type:

  1945 				typeref     = attr->value;

  1946 				array->type = elfParseType(unit, typeref);

  1947 				break;

  1948 			default:

  1949 				fprintf(stderr, "Unknown array attribute %02x\n", attr->name);

  1950 			}

  1951 		}

  1952 		if (abbrev->hasChildren)

  1953 		{

  1954 			int bytes;

  1955 			u32 num = elfReadLEB128(data, &bytes);

  1956 			data += bytes;

  1957 			int index     = 0;

  1958 			int maxBounds = 0;

  1959 			while (num)

  1960 			{

  1961 				ELFAbbrev *abbr = elfGetAbbrev(unit->abbrevs, num);

  1962 

  1963 				switch (abbr->tag)

  1964 				{

  1965 				case DW_TAG_subrange_type:

  1966 				{

  1967 					if (maxBounds == index)

  1968 					{

  1969 						maxBounds    += 4;

  1970 						array->bounds = (int *)realloc(array->bounds,

  1971 						                               sizeof(int)*maxBounds);

  1972 					}

  1973 					for (int i = 0; i < abbr->numAttrs; i++)

  1974 					{

  1975 						ELFAttr *attr = &abbr->attrs[i];

  1976 						data = elfReadAttribute(data, attr);

  1977 						switch (attr->name)

  1978 						{

  1979 						case DW_AT_upper_bound:

  1980 							array->bounds[index] = attr->value+1;

  1981 							break;

  1982 						case DW_AT_type: // ignore

  1983 							break;

  1984 						default:

  1985 							fprintf(stderr, "Unknown subrange attribute %02x\n",

  1986 							        attr->name);

  1987 						}

  1988 					}

  1989 					index++;

  1990 					break;

  1991 				}

  1992 				default:

  1993 					fprintf(stderr, "Unknown array tag %02x\n", abbr->tag);

  1994 					data = elfSkipData(data, abbr, unit->abbrevs);

  1995 					break;

  1996 				}

  1997 				num   = elfReadLEB128(data, &bytes);

  1998 				data += bytes;

  1999 			}

  2000 			array->maxBounds = index;

  2001 		}

  2002 		t->size = array->type->size;

  2003 		for (i = 0; i < array->maxBounds; i++)

  2004 			t->size *= array->bounds[i];

  2005 		t->array = array;

  2006 		*type    = t;

  2007 		return;

  2008 		break;

  2009 	}

  2010 	default:

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

  2012 		exit(-1);

  2013 	}

  2014 }

  2015 

  2016 Type *elfParseType(CompileUnit *unit, u32 offset)

  2017 {

  2018 	Type *t = unit->types;

  2019 

  2020 	while (t)

  2021 	{

  2022 		if (t->offset == offset)

  2023 			return t;

  2024 		t = t->next;

  2025 	}

  2026 	if (offset == 0)

  2027 	{

  2028 		Type *t = (Type *)calloc(sizeof(Type), 1);

  2029 		t->type   = TYPE_void;

  2030 		t->offset = 0;

  2031 		elfAddType(t, unit, 0);

  2032 		return t;

  2033 	}

  2034 	u8 *data = unit->top + offset;

  2035 	int bytes;

  2036 	int abbrevNum = elfReadLEB128(data, &bytes);

  2037 	data += bytes;

  2038 	Type *type = NULL;

  2039 

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

  2041 

  2042 	elfParseType(data, offset, abbrev, unit, &type);

  2043 	return type;

  2044 }

  2045 

  2046 void elfGetObjectAttributes(CompileUnit *unit, u32 offset, Object *o)

  2047 {

  2048 	u8 *data = unit->top + offset;

  2049 	int bytes;

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

  2051 	data += bytes;

  2052 

  2053 	if (!abbrevNum)

  2054 	{

  2055 		return;

  2056 	}

  2057 

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

  2059 

  2060 	for (int i = 0; i < abbrev->numAttrs; i++)

  2061 	{

  2062 		ELFAttr *attr = &abbrev->attrs[i];

  2063 		data = elfReadAttribute(data, attr);

  2064 		switch (attr->name)

  2065 		{

  2066 		case DW_AT_location:

  2067 			o->location = attr->block;

  2068 			break;

  2069 		case DW_AT_name:

  2070 			if (o->name == NULL)

  2071 				o->name = attr->string;

  2072 			break;

  2073 		case DW_AT_MIPS_linkage_name:

  2074 			o->name = attr->string;

  2075 			break;

  2076 		case DW_AT_decl_file:

  2077 			o->file = attr->value;

  2078 			break;

  2079 		case DW_AT_decl_line:

  2080 			o->line = attr->value;

  2081 			break;

  2082 		case DW_AT_type:

  2083 			o->type = elfParseType(unit, attr->value);

  2084 			break;

  2085 		case DW_AT_external:

  2086 			o->external = attr->flag;

  2087 			break;

  2088 		case DW_AT_const_value:

  2089 		case DW_AT_abstract_origin:

  2090 		case DW_AT_declaration:

  2091 		case DW_AT_artificial:

  2092 			// todo

  2093 			break;

  2094 		case DW_AT_specification:

  2095 			// TODO:

  2096 			break;

  2097 		default:

  2098 			fprintf(stderr, "Unknown object attribute %02x\n", attr->name);

  2099 			break;

  2100 		}

  2101 	}

  2102 }

  2103 

  2104 u8 *elfParseObject(u8 *data, ELFAbbrev *abbrev, CompileUnit *unit,

  2105                    Object **object)

  2106 {

  2107 	Object *o = (Object *)calloc(sizeof(Object), 1);

  2108 

  2109 	o->next = NULL;

  2110 

  2111 	for (int i = 0; i < abbrev->numAttrs; i++)

  2112 	{

  2113 		ELFAttr *attr = &abbrev->attrs[i];

  2114 		data = elfReadAttribute(data, attr);

  2115 		switch (attr->name)

  2116 		{

  2117 		case DW_AT_location:

  2118 			o->location = attr->block;

  2119 			break;

  2120 		case DW_AT_name:

  2121 			if (o->name == NULL)

  2122 				o->name = attr->string;

  2123 			break;

  2124 		case DW_AT_MIPS_linkage_name:

  2125 			o->name = attr->string;

  2126 			break;

  2127 		case DW_AT_decl_file:

  2128 			o->file = attr->value;

  2129 			break;

  2130 		case DW_AT_decl_line:

  2131 			o->line = attr->value;

  2132 			break;

  2133 		case DW_AT_type:

  2134 			o->type = elfParseType(unit, attr->value);

  2135 			break;

  2136 		case DW_AT_external:

  2137 			o->external = attr->flag;

  2138 			break;

  2139 		case DW_AT_abstract_origin:

  2140 			elfGetObjectAttributes(unit, attr->value, o);

  2141 			break;

  2142 		case DW_AT_const_value:

  2143 		case DW_AT_declaration:

  2144 		case DW_AT_artificial:

  2145 			break;

  2146 		case DW_AT_specification:

  2147 			// TODO:

  2148 			break;

  2149 		default:

  2150 			fprintf(stderr, "Unknown object attribute %02x\n", attr->name);

  2151 			break;

  2152 		}

  2153 	}

  2154 	*object = o;

  2155 	return data;

  2156 }

  2157 

  2158 u8 *elfParseBlock(u8 *data, ELFAbbrev *abbrev, CompileUnit *unit,

  2159                   Function *func, Object **lastVar)

  2160 {

  2161 	int bytes;

  2162 	u32 start = func->lowPC;

  2163 	u32 end   = func->highPC;

  2164 

  2165 	for (int i = 0; i < abbrev->numAttrs; i++)

  2166 	{

  2167 		ELFAttr *attr = &abbrev->attrs[i];

  2168 		data = elfReadAttribute(data, attr);

  2169 		switch (attr->name)

  2170 		{

  2171 		case DW_AT_sibling:

  2172 			break;

  2173 		case DW_AT_low_pc:

  2174 			start = attr->value;

  2175 			break;

  2176 		case DW_AT_high_pc:

  2177 			end = attr->value;

  2178 			break;

  2179 		case DW_AT_ranges: // ignore for now

  2180 			break;

  2181 		default:

  2182 			fprintf(stderr, "Unknown block attribute %02x\n", attr->name);

  2183 			break;

  2184 		}

  2185 	}

  2186 

  2187 	if (abbrev->hasChildren)

  2188 	{

  2189 		int nesting = 1;

  2190 

  2191 		while (nesting)

  2192 		{

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

  2194 			data += bytes;

  2195 

  2196 			if (!abbrevNum)

  2197 			{

  2198 				nesting--;

  2199 				continue;

  2200 			}

  2201 

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

  2203 

  2204 			switch (abbrev->tag)

  2205 			{

  2206 CASE_TYPE_TAG:       // types only parsed when used

  2207 			case DW_TAG_label: // not needed

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

  2209 				break;

  2210 			case DW_TAG_lexical_block:

  2211 				data = elfParseBlock(data, abbrev, unit, func, lastVar);

  2212 				break;

  2213 			case DW_TAG_subprogram:

  2214 			{

  2215 				Function *f = NULL;

  2216 				data = elfParseFunction(data, abbrev, unit, &f);

  2217 				if (f != NULL)

  2218 				{

  2219 					if (unit->lastFunction)

  2220 						unit->lastFunction->next = f;

  2221 					else

  2222 						unit->functions = f;

  2223 					unit->lastFunction = f;

  2224 				}

  2225 				break;

  2226 			}

  2227 			case DW_TAG_variable:

  2228 			{

  2229 				Object *o;

  2230 				data = elfParseObject(data, abbrev, unit, &o);

  2231 				if (o->startScope == 0)

  2232 					o->startScope = start;

  2233 				if (o->endScope == 0)

  2234 					o->endScope = 0;

  2235 				if (func->variables)

  2236 					(*lastVar)->next = o;

  2237 				else

  2238 					func->variables = o;

  2239 				*lastVar = o;

  2240 				break;

  2241 			}

  2242 			case DW_TAG_inlined_subroutine:

  2243 				// TODO:

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

  2245 				break;

  2246 			default:

  2247 			{

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

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

  2250 				break;

  2251 			}

  2252 			}

  2253 		}

  2254 	}

  2255 	return data;

  2256 }

  2257 

  2258 void elfGetFunctionAttributes(CompileUnit *unit, u32 offset, Function *func)

  2259 {

  2260 	u8 *data = unit->top + offset;

  2261 	int bytes;

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

  2263 	data += bytes;

  2264 

  2265 	if (!abbrevNum)

  2266 	{

  2267 		return;

  2268 	}

  2269 

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

  2271 

  2272 	for (int i = 0; i < abbrev->numAttrs; i++)

  2273 	{

  2274 		ELFAttr *attr = &abbrev->attrs[i];

  2275 		data = elfReadAttribute(data, attr);

  2276 

  2277 		switch (attr->name)

  2278 		{

  2279 		case DW_AT_sibling:

  2280 			break;

  2281 		case DW_AT_name:

  2282 			if (func->name == NULL)

  2283 				func->name = attr->string;

  2284 			break;

  2285 		case DW_AT_MIPS_linkage_name:

  2286 			func->name = attr->string;

  2287 			break;

  2288 		case DW_AT_low_pc:

  2289 			func->lowPC = attr->value;

  2290 			break;

  2291 		case DW_AT_high_pc:

  2292 			func->highPC = attr->value;

  2293 			break;

  2294 		case DW_AT_decl_file:

  2295 			func->file = attr->value;

  2296 			break;

  2297 		case DW_AT_decl_line:

  2298 			func->line = attr->value;

  2299 			break;

  2300 		case DW_AT_external:

  2301 			func->external = attr->flag;

  2302 			break;

  2303 		case DW_AT_frame_base:

  2304 			func->frameBase = attr->block;

  2305 			break;

  2306 		case DW_AT_type:

  2307 			func->returnType = elfParseType(unit, attr->value);

  2308 			break;

  2309 		case DW_AT_inline:

  2310 		case DW_AT_specification:

  2311 		case DW_AT_declaration:

  2312 		case DW_AT_artificial:

  2313 		case DW_AT_prototyped:

  2314 		case DW_AT_proc_body:

  2315 		case DW_AT_save_offset:

  2316 		case DW_AT_user_2002:

  2317 		case DW_AT_virtuality:

  2318 		case DW_AT_containing_type:

  2319 		case DW_AT_accessibility:

  2320 			// todo;

  2321 			break;

  2322 		case DW_AT_vtable_elem_location:

  2323 			free(attr->block);

  2324 			break;

  2325 		default:

  2326 			fprintf(stderr, "Unknown function attribute %02x\n", attr->name);

  2327 			break;

  2328 		}

  2329 	}

  2330 

  2331 	return;

  2332 }

  2333 

  2334 u8 *elfParseFunction(u8 *data, ELFAbbrev *abbrev, CompileUnit *unit,

  2335                      Function **f)

  2336 {

  2337 	Function *func = (Function *)calloc(sizeof(Function), 1);

  2338 	*f = func;

  2339 

  2340 	int  bytes;

  2341 	bool mangled     = false;

  2342 	bool declaration = false;

  2343 	for (int i = 0; i < abbrev->numAttrs; i++)

  2344 	{

  2345 		ELFAttr *attr = &abbrev->attrs[i];

  2346 		data = elfReadAttribute(data, attr);

  2347 		switch (attr->name)

  2348 		{

  2349 		case DW_AT_sibling:

  2350 			break;

  2351 		case DW_AT_name:

  2352 			if (func->name == NULL)

  2353 				func->name = attr->string;

  2354 			break;

  2355 		case DW_AT_MIPS_linkage_name:

  2356 			func->name = attr->string;

  2357 			mangled    = true;

  2358 			break;

  2359 		case DW_AT_low_pc:

  2360 			func->lowPC = attr->value;

  2361 			break;

  2362 		case DW_AT_high_pc:

  2363 			func->highPC = attr->value;

  2364 			break;

  2365 		case DW_AT_prototyped:

  2366 			break;

  2367 		case DW_AT_decl_file:

  2368 			func->file = attr->value;

  2369 			break;

  2370 		case DW_AT_decl_line:

  2371 			func->line = attr->value;

  2372 			break;

  2373 		case DW_AT_external:

  2374 			func->external = attr->flag;

  2375 			break;

  2376 		case DW_AT_frame_base:

  2377 			func->frameBase = attr->block;

  2378 			break;

  2379 		case DW_AT_type:

  2380 			func->returnType = elfParseType(unit, attr->value);

  2381 			break;

  2382 		case DW_AT_abstract_origin:

  2383 			elfGetFunctionAttributes(unit, attr->value, func);

  2384 			break;

  2385 		case DW_AT_declaration:

  2386 			declaration = attr->flag;

  2387 			break;

  2388 		case DW_AT_inline:

  2389 		case DW_AT_specification:

  2390 		case DW_AT_artificial:

  2391 		case DW_AT_proc_body:

  2392 		case DW_AT_save_offset:

  2393 		case DW_AT_user_2002:

  2394 		case DW_AT_virtuality:

  2395 		case DW_AT_containing_type:

  2396 		case DW_AT_accessibility:

  2397 			// todo;

  2398 			break;

  2399 		case DW_AT_vtable_elem_location:

  2400 			free(attr->block);

  2401 			break;

  2402 		default:

  2403 			fprintf(stderr, "Unknown function attribute %02x\n", attr->name);

  2404 			break;

  2405 		}

  2406 	}

  2407 

  2408 	if (declaration)

  2409 	{

  2410 		elfCleanUp(func);

  2411 		free(func);

  2412 		*f = NULL;

  2413 

  2414 		while (1)

  2415 		{

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

  2417 			data += bytes;

  2418 

  2419 			if (!abbrevNum)

  2420 			{

  2421 				return data;

  2422 			}

  2423 

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

  2425 

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

  2427 		}

  2428 	}

  2429 

  2430 	if (abbrev->hasChildren)

  2431 	{

  2432 		int     nesting   = 1;

  2433 		Object *lastParam = NULL;

  2434 		Object *lastVar   = NULL;

  2435 

  2436 		while (nesting)

  2437 		{

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

  2439 			data += bytes;

  2440 

  2441 			if (!abbrevNum)

  2442 			{

  2443 				nesting--;

  2444 				continue;

  2445 			}

  2446 

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

  2448 

  2449 			switch (abbrev->tag)

  2450 			{

  2451 CASE_TYPE_TAG:       // no need to parse types. only parsed when used

  2452 			case DW_TAG_label: // not needed

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

  2454 				break;

  2455 			case DW_TAG_subprogram:

  2456 			{

  2457 				Function *fnc = NULL;

  2458 				data = elfParseFunction(data, abbrev, unit, &fnc);

  2459 				if (fnc != NULL)

  2460 				{

  2461 					if (unit->lastFunction == NULL)

  2462 						unit->functions = fnc;

  2463 					else

  2464 						unit->lastFunction->next = fnc;

  2465 					unit->lastFunction = fnc;

  2466 				}

  2467 				break;

  2468 			}

  2469 			case DW_TAG_lexical_block:

  2470 			{

  2471 				data = elfParseBlock(data, abbrev, unit, func, &lastVar);

  2472 				break;

  2473 			}

  2474 			case DW_TAG_formal_parameter:

  2475 			{

  2476 				Object *o;

  2477 				data = elfParseObject(data, abbrev, unit, &o);

  2478 				if (func->parameters)

  2479 					lastParam->next = o;

  2480 				else

  2481 					func->parameters = o;

  2482 				lastParam = o;

  2483 				break;

  2484 			}

  2485 			case DW_TAG_variable:

  2486 			{

  2487 				Object *o;

  2488 				data = elfParseObject(data, abbrev, unit, &o);

  2489 				if (func->variables)

  2490 					lastVar->next = o;

  2491 				else

  2492 					func->variables = o;

  2493 				lastVar = o;

  2494 				break;

  2495 			}

  2496 			case DW_TAG_unspecified_parameters:

  2497 			case DW_TAG_inlined_subroutine:

  2498 			{

  2499 				// todo

  2500 				for (int i = 0; i < abbrev->numAttrs; i++)

  2501 				{

  2502 					data = elfReadAttribute(data,  &abbrev->attrs[i]);

  2503 					if (abbrev->attrs[i].form == DW_FORM_block1)

  2504 						free(abbrev->attrs[i].block);

  2505 				}

  2506 

  2507 				if (abbrev->hasChildren)

  2508 					nesting++;

  2509 				break;

  2510 			}

  2511 			default:

  2512 			{

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

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

  2515 				break;

  2516 			}

  2517 			}

  2518 		}

  2519 	}

  2520 	return data;

  2521 }

  2522 

  2523 u8 *elfParseUnknownData(u8 *data, ELFAbbrev *abbrev, ELFAbbrev **abbrevs)

  2524 {

  2525 	int i;

  2526 	int bytes;

  2527 	//  switch(abbrev->tag) {

  2528 	//  default:

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

  2530 

  2531 	for (i = 0; i < abbrev->numAttrs; i++)

  2532 	{

  2533 		data = elfReadAttribute(data,  &abbrev->attrs[i]);

  2534 		if (abbrev->attrs[i].form == DW_FORM_block1)

  2535 			free(abbrev->attrs[i].block);

  2536 	}

  2537 

  2538 	if (abbrev->hasChildren)

  2539 	{

  2540 		int nesting = 1;

  2541 		while (nesting)

  2542 		{

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

  2544 			data += bytes;

  2545 

  2546 			if (!abbrevNum)

  2547 			{

  2548 				nesting--;

  2549 				continue;

  2550 			}

  2551 

  2552 			abbrev = elfGetAbbrev(abbrevs, abbrevNum);

  2553 

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

  2555 

  2556 			for (i = 0; i < abbrev->numAttrs; i++)

  2557 			{

  2558 				data = elfReadAttribute(data,  &abbrev->attrs[i]);

  2559 				if (abbrev->attrs[i].form == DW_FORM_block1)

  2560 					free(abbrev->attrs[i].block);

  2561 			}

  2562 

  2563 			if (abbrev->hasChildren)

  2564 			{

  2565 				nesting++;

  2566 			}

  2567 		}

  2568 	}

  2569 	//  }

  2570 	return data;

  2571 }

  2572 

  2573 u8 *elfParseCompileUnitChildren(u8 *data, CompileUnit *unit)

  2574 {

  2575 	int bytes;

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

  2577 	data += bytes;

  2578 	Object *lastObj = NULL;

  2579 	while (abbrevNum)

  2580 	{

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

  2582 		switch (abbrev->tag)

  2583 		{

  2584 		case DW_TAG_subprogram:

  2585 		{

  2586 			Function *func = NULL;

  2587 			data = elfParseFunction(data, abbrev, unit, &func);

  2588 			if (func != NULL)

  2589 			{

  2590 				if (unit->lastFunction)

  2591 					unit->lastFunction->next = func;

  2592 				else

  2593 					unit->functions = func;

  2594 				unit->lastFunction = func;

  2595 			}

  2596 			break;

  2597 		}

  2598 CASE_TYPE_TAG:

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

  2600 			break;

  2601 		case DW_TAG_variable:

  2602 		{

  2603 			Object *var = NULL;

  2604 			data = elfParseObject(data, abbrev, unit, &var);

  2605 			if (lastObj)

  2606 				lastObj->next = var;

  2607 			else

  2608 				unit->variables = var;

  2609 			lastObj = var;

  2610 			break;

  2611 		}

  2612 		default:

  2613 			data = elfParseUnknownData(data, abbrev, unit->abbrevs);

  2614 			break;

  2615 		}

  2616 

  2617 		abbrevNum = elfReadLEB128(data, &bytes);

  2618 		data     += bytes;

  2619 	}

  2620 	return data;

  2621 }

  2622 

  2623 CompileUnit *elfParseCompUnit(u8 *data, u8 *abbrevData)

  2624 {

  2625 	int bytes;

  2626 	u8 *top = data;

  2627 

  2628 	u32 length = elfRead4Bytes(data);

  2629 	data += 4;

  2630 

  2631 	u16 version = elfRead2Bytes(data);

  2632 	data += 2;

  2633 

  2634 	u32 offset = elfRead4Bytes(data);

  2635 	data += 4;

  2636 

  2637 	u8 addrSize = *data++;

  2638 

  2639 	if (version != 2)

  2640 	{

  2641 		fprintf(stderr, "Unsupported debugging information version %d\n", version);

  2642 		return NULL;

  2643 	}

  2644 

  2645 	if (addrSize != 4)

  2646 	{

  2647 		fprintf(stderr, "Unsupported address size %d\n", addrSize);

  2648 		return NULL;

  2649 	}

  2650 

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

  2652 

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

  2654 	data += bytes;

  2655 

  2656 	ELFAbbrev *abbrev = elfGetAbbrev(abbrevs, abbrevNum);

  2657 

  2658 	CompileUnit *unit = (CompileUnit *)calloc(sizeof(CompileUnit), 1);

  2659 	unit->top     = top;

  2660 	unit->length  = length;

  2661 	unit->abbrevs = abbrevs;

  2662 	unit->next    = NULL;

  2663 

  2664 	elfCurrentUnit = unit;

  2665 

  2666 	int i;

  2667 

  2668 	for (i = 0; i < abbrev->numAttrs; i++)

  2669 	{

  2670 		ELFAttr *attr = &abbrev->attrs[i];

  2671 		data = elfReadAttribute(data, attr);

  2672 

  2673 		switch (attr->name)

  2674 		{

  2675 		case DW_AT_name:

  2676 			unit->name = attr->string;

  2677 			break;

  2678 		case DW_AT_stmt_list:

  2679 			unit->hasLineInfo = true;

  2680 			unit->lineInfo    = attr->value;

  2681 			break;

  2682 		case DW_AT_low_pc:

  2683 			unit->lowPC = attr->value;

  2684 			break;

  2685 		case DW_AT_high_pc:

  2686 			unit->highPC = attr->value;

  2687 			break;

  2688 		case DW_AT_compdir:

  2689 			unit->compdir = attr->string;

  2690 			break;

  2691 		// ignore

  2692 		case DW_AT_language:

  2693 		case DW_AT_producer:

  2694 		case DW_AT_macro_info:

  2695 		case DW_AT_entry_pc:

  2696 			break;

  2697 		default:

  2698 			fprintf(stderr, "Unknown attribute %02x\n", attr->name);

  2699 			break;

  2700 		}

  2701 	}

  2702 

  2703 	if (abbrev->hasChildren)

  2704 		elfParseCompileUnitChildren(data, unit);

  2705 

  2706 	return unit;

  2707 }

  2708 

  2709 void elfParseAranges(u8 *data)

  2710 {

  2711 	ELFSectionHeader *sh = elfGetSectionByName(".debug_aranges");

  2712 	if (sh == NULL)

  2713 	{

  2714 		fprintf(stderr, "No aranges found\n");

  2715 		return;

  2716 	}

  2717 

  2718 	data = elfReadSection(data, sh);

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

  2720 

  2721 	int      max    = 4;

  2722 	ARanges *ranges = (ARanges *)calloc(sizeof(ARanges), 4);

  2723 

  2724 	int index = 0;

  2725 

  2726 	while (data < end)

  2727 	{

  2728 		u32 len = elfRead4Bytes(data);

  2729 		data += 4;

  2730 		//    u16 version = elfRead2Bytes(data);

  2731 		data += 2;

  2732 		u32 offset = elfRead4Bytes(data);

  2733 		data += 4;

  2734 		//    u8 addrSize = *data++;

  2735 		//    u8 segSize = *data++;

  2736 		data += 2; // remove if uncommenting above

  2737 		data += 4;

  2738 		ranges[index].count  = (len-20)/8;

  2739 		ranges[index].offset = offset;

  2740 		ranges[index].ranges = (ARange *)calloc(sizeof(ARange), (len-20)/8);

  2741 		int i = 0;

  2742 		while (true)

  2743 		{

  2744 			u32 addr = elfRead4Bytes(data);

  2745 			data += 4;

  2746 			u32 len = elfRead4Bytes(data);

  2747 			data += 4;

  2748 			if (addr == 0 && len == 0)

  2749 				break;

  2750 			ranges[index].ranges[i].lowPC  = addr;

  2751 			ranges[index].ranges[i].highPC = addr+len;

  2752 			i++;

  2753 		}

  2754 		index++;

  2755 		if (index == max)

  2756 		{

  2757 			max   += 4;

  2758 			ranges = (ARanges *)realloc(ranges, max*sizeof(ARanges));

  2759 		}

  2760 	}

  2761 	elfDebugInfo->numRanges = index;

  2762 	elfDebugInfo->ranges    = ranges;

  2763 }

  2764 

  2765 void elfReadSymtab(u8 *data)

  2766 {

  2767 	ELFSectionHeader *sh = elfGetSectionByName(".symtab");

  2768 	int table = READ32LE(&sh->link);

  2769 

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

  2771 

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

  2773 

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

  2775 	elfSymbolsCount = 0;

  2776 

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

  2778 

  2779 	int i;

  2780 

  2781 	for (i = 0; i < count; i++)

  2782 	{

  2783 		ELFSymbol *s       = &symtab[i];

  2784 		int        type    = s->info & 15;

  2785 		int        binding = s->info >> 4;

  2786 

  2787 		if (binding)

  2788 		{

  2789 			Symbol *sym = &elfSymbols[elfSymbolsCount];

  2790 			sym->name    = &strtable[READ32LE(&s->name)];

  2791 			sym->binding = binding;

  2792 			sym->type    = type;

  2793 			sym->value   = READ32LE(&s->value);

  2794 			sym->size    = READ32LE(&s->size);

  2795 			elfSymbolsCount++;

  2796 		}

  2797 	}

  2798 	for (i = 0; i < count; i++)

  2799 	{

  2800 		ELFSymbol *s    = &symtab[i];

  2801 		int        bind = s->info>>4;

  2802 		int        type = s->info & 15;

  2803 

  2804 		if (!bind)

  2805 		{

  2806 			Symbol *sym = &elfSymbols[elfSymbolsCount];

  2807 			sym->name    = &strtable[READ32LE(&s->name)];

  2808 			sym->binding = (s->info >> 4);

  2809 			sym->type    = type;

  2810 			sym->value   = READ32LE(&s->value);

  2811 			sym->size    = READ32LE(&s->size);

  2812 			elfSymbolsCount++;

  2813 		}

  2814 	}

  2815 	elfSymbolsStrTab = strtable;

  2816 	//  free(symtab);

  2817 }

  2818 

  2819 bool elfReadProgram(ELFHeader *eh, u8 *data, int& size, bool parseDebug)

  2820 {

  2821 	int count = READ16LE(&eh->e_phnum);

  2822 	int i;

  2823 

  2824 	if (READ32LE(&eh->e_entry) == 0x2000000)

  2825 		cpuIsMultiBoot = true;

  2826 

  2827 	// read program headers... should probably move this code down

  2828 	u8 *p = data + READ32LE(&eh->e_phoff);

  2829 	size = 0;

  2830 	for (i = 0; i < count; i++)

  2831 	{

  2832 		ELFProgramHeader *ph = (ELFProgramHeader *)p;

  2833 		p += sizeof(ELFProgramHeader);

  2834 		if (READ16LE(&eh->e_phentsize) != sizeof(ELFProgramHeader))

  2835 		{

  2836 			p += READ16LE(&eh->e_phentsize) - sizeof(ELFProgramHeader);

  2837 		}

  2838 

  2839 		//    printf("PH %d %08x %08x %08x %08x %08x %08x %08x %08x\n",

  2840 		//     i, ph->type, ph->offset, ph->vaddr, ph->paddr,

  2841 		//     ph->filesz, ph->memsz, ph->flags, ph->align);

  2842 		if (cpuIsMultiBoot)

  2843 		{

  2844 			if (READ32LE(&ph->paddr) >= 0x2000000 &&

  2845 			    READ32LE(&ph->paddr) <= 0x203ffff)

  2846 			{

  2847 				memcpy(&workRAM[READ32LE(&ph->paddr) & 0x3ffff],

  2848 				       data + READ32LE(&ph->offset),

  2849 				       READ32LE(&ph->filesz));

  2850 			}

  2851 		}

  2852 		else

  2853 		{

  2854 			if (READ32LE(&ph->paddr) >= 0x8000000 &&

  2855 			    READ32LE(&ph->paddr) <= 0x9ffffff)

  2856 			{

  2857 				memcpy(&rom[READ32LE(&ph->paddr) & 0x1ffffff],

  2858 				       data + READ32LE(&ph->offset),

  2859 				       READ32LE(&ph->filesz));

  2860 				size += READ32LE(&ph->filesz);

  2861 			}

  2862 		}

  2863 	}

  2864 

  2865 	char *stringTable = NULL;

  2866 

  2867 	// read section headers

  2868 	p     = data + READ32LE(&eh->e_shoff);

  2869 	count = READ16LE(&eh->e_shnum);

  2870 

  2871 	ELFSectionHeader **sh = (ELFSectionHeader * *)

  2872 	                        malloc(sizeof(ELFSectionHeader *) * count);

  2873 

  2874 	for (i = 0; i < count; i++)

  2875 	{

  2876 		sh[i] = (ELFSectionHeader *)p;

  2877 		p    += sizeof(ELFSectionHeader);

  2878 		if (READ16LE(&eh->e_shentsize) != sizeof(ELFSectionHeader))

  2879 			p += READ16LE(&eh->e_shentsize) - sizeof(ELFSectionHeader);

  2880 	}

  2881 

  2882 	if (READ16LE(&eh->e_shstrndx) != 0)

  2883 	{

  2884 		stringTable = (char *)elfReadSection(data,

  2885 		                                     sh[READ16LE(&eh->e_shstrndx)]);

  2886 	}

  2887 

  2888 	elfSectionHeaders = sh;

  2889 	elfSectionHeadersStringTable = stringTable;

  2890 	elfSectionHeadersCount       = count;

  2891 

  2892 	for (i = 0; i < count; i++)

  2893 	{

  2894 		//    printf("SH %d %-20s %08x %08x %08x %08x %08x %08x %08x %08x\n",

  2895 		//   i, &stringTable[sh[i]->name], sh[i]->name, sh[i]->type,

  2896 		//   sh[i]->flags, sh[i]->addr, sh[i]->offset, sh[i]->size,

  2897 		//   sh[i]->link, sh[i]->info);

  2898 		if (READ32LE(&sh[i]->flags) & 2) // load section

  2899 		{

  2900 			if (cpuIsMultiBoot)

  2901 			{

  2902 				if (READ32LE(&sh[i]->addr) >= 0x2000000 &&

  2903 				    READ32LE(&sh[i]->addr) <= 0x203ffff)

  2904 				{

  2905 					memcpy(&workRAM[READ32LE(&sh[i]->addr) & 0x3ffff], data +

  2906 					       READ32LE(&sh[i]->offset),

  2907 					       READ32LE(&sh[i]->size));

  2908 				}

  2909 			}

  2910 			else

  2911 			{

  2912 				if (READ32LE(&sh[i]->addr) >= 0x8000000 &&

  2913 				    READ32LE(&sh[i]->addr) <= 0x9ffffff)

  2914 				{

  2915 					memcpy(&rom[READ32LE(&sh[i]->addr) & 0x1ffffff],

  2916 					       data + READ32LE(&sh[i]->offset),

  2917 					       READ32LE(&sh[i]->size));

  2918 					size += READ32LE(&sh[i]->size);

  2919 				}

  2920 			}

  2921 		}

  2922 	}

  2923 

  2924 	if (parseDebug)

  2925 	{

  2926 		fprintf(stderr, "Parsing debug info\n");

  2927 

  2928 		ELFSectionHeader *dbgHeader = elfGetSectionByName(".debug_info");

  2929 		if (dbgHeader == NULL)

  2930 		{

  2931 			fprintf(stderr, "Cannot find debug information\n");

  2932 			goto end;

  2933 		}

  2934 

  2935 		ELFSectionHeader *h = elfGetSectionByName(".debug_abbrev");

  2936 		if (h == NULL)

  2937 		{

  2938 			fprintf(stderr, "Cannot find abbreviation table\n");

  2939 			goto end;

  2940 		}

  2941 

  2942 		elfDebugInfo = (DebugInfo *)calloc(sizeof(DebugInfo), 1);

  2943 		u8 *abbrevdata = elfReadSection(data, h);

  2944 

  2945 		h = elfGetSectionByName(".debug_str");

  2946 

  2947 		if (h == NULL)

  2948 			elfDebugStrings = NULL;

  2949 		else

  2950 			elfDebugStrings = (char *)elfReadSection(data, h);

  2951 

  2952 		u8 *debugdata = elfReadSection(data, dbgHeader);

  2953 

  2954 		elfDebugInfo->debugdata = data;

  2955 		elfDebugInfo->infodata  = debugdata;

  2956 

  2957 		u32 total = READ32LE(&dbgHeader->size);

  2958 		u8 *end   = debugdata + total;

  2959 		u8 *ddata = debugdata;

  2960 

  2961 		CompileUnit *last = NULL;

  2962 		CompileUnit *unit = NULL;

  2963 

  2964 		while (ddata < end)

  2965 		{

  2966 			unit         = elfParseCompUnit(ddata, abbrevdata);

  2967 			unit->offset = ddata-debugdata;

  2968 			elfParseLineInfo(unit, data);

  2969 			if (last == NULL)

  2970 				elfCompileUnits = unit;

  2971 			else

  2972 				last->next = unit;

  2973 			last   = unit;

  2974 			ddata += 4 + unit->length;

  2975 		}

  2976 		elfParseAranges(data);

  2977 		CompileUnit *comp = elfCompileUnits;

  2978 		while (comp)

  2979 		{

  2980 			ARanges *r = elfDebugInfo->ranges;

  2981 			for (int i = 0; i < elfDebugInfo->numRanges; i++)

  2982 				if (r[i].offset == comp->offset)

  2983 				{

  2984 					comp->ranges = &r[i];

  2985 					break;

  2986 				}

  2987 			comp = comp->next;

  2988 		}

  2989 		elfParseCFA(data);

  2990 		elfReadSymtab(data);

  2991 	}

  2992 end:

  2993 	if (sh)

  2994 	{

  2995 		free(sh);

  2996 	}

  2997 

  2998 	elfSectionHeaders = NULL;

  2999 	elfSectionHeadersStringTable = NULL;

  3000 	elfSectionHeadersCount       = 0;

  3001 

  3002 	return true;

  3003 }

  3004 

  3005 extern bool8 parseDebug;

  3006 

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

  3008 {

  3009 	fseek(f, 0, SEEK_END);

  3010 	long size = ftell(f);

  3011 	elfFileData = (u8 *)malloc(size);

  3012 	fseek(f, 0, SEEK_SET);

  3013 	fread(elfFileData, 1, size, f);

  3014 	fclose(f);

  3015 

  3016 	ELFHeader *header = (ELFHeader *)elfFileData;

  3017 

  3018 	if (READ32LE(&header->magic) != 0x464C457F ||

  3019 	    READ16LE(&header->e_machine) != 40 ||

  3020 	    header->clazz != 1)

  3021 	{

  3022 		systemMessage(0, N_("Not a valid ELF file %s"), name);

  3023 		free(elfFileData);

  3024 		elfFileData = NULL;

  3025 		return false;

  3026 	}

  3027 

  3028 	if (!elfReadProgram(header, elfFileData, siz, parseDebug))

  3029 	{

  3030 		free(elfFileData);

  3031 		elfFileData = NULL;

  3032 		return false;

  3033 	}

  3034 

  3035 	return true;

  3036 }

  3037 

  3038 void elfCleanUp(Object *o)

  3039 {

  3040 	free(o->location);

  3041 }

  3042 

  3043 void elfCleanUp(Function *func)

  3044 {

  3045 	Object *o = func->parameters;

  3046 	while (o)

  3047 	{

  3048 		elfCleanUp(o);

  3049 		Object *next = o->next;

  3050 		free(o);

  3051 		o = next;

  3052 	}

  3053 

  3054 	o = func->variables;

  3055 	while (o)

  3056 	{

  3057 		elfCleanUp(o);

  3058 		Object *next = o->next;

  3059 		free(o);

  3060 		o = next;

  3061 	}

  3062 	free(func->frameBase);

  3063 }

  3064 

  3065 void elfCleanUp(ELFAbbrev **abbrevs)

  3066 {

  3067 	for (int i = 0; i < 121; i++)

  3068 	{

  3069 		ELFAbbrev *abbrev = abbrevs[i];

  3070 

  3071 		while (abbrev)

  3072 		{

  3073 			free(abbrev->attrs);

  3074 			ELFAbbrev *next = abbrev->next;

  3075 			free(abbrev);

  3076 

  3077 			abbrev = next;

  3078 		}

  3079 	}

  3080 }

  3081 

  3082 void elfCleanUp(Type *t)

  3083 {

  3084 	switch (t->type)

  3085 	{

  3086 	case TYPE_function:

  3087 		if (t->function)

  3088 		{

  3089 			Object *o = t->function->args;

  3090 			while (o)

  3091 			{

  3092 				elfCleanUp(o);

  3093 				Object *next = o->next;

  3094 				free(o);

  3095 				o = next;

  3096 			}

  3097 			free(t->function);

  3098 		}

  3099 		break;

  3100 	case TYPE_array:

  3101 		if (t->array)

  3102 		{

  3103 			free(t->array->bounds);

  3104 			free(t->array);

  3105 		}

  3106 		break;

  3107 	case TYPE_struct:

  3108 	case TYPE_union:

  3109 		if (t->structure)

  3110 		{

  3111 			for (int i = 0; i < t->structure->memberCount; i++)

  3112 			{

  3113 				free(t->structure->members[i].location);

  3114 			}

  3115 			free(t->structure->members);

  3116 			free(t->structure);

  3117 		}

  3118 		break;

  3119 	case TYPE_enum:

  3120 		if (t->enumeration)

  3121 		{

  3122 			free(t->enumeration->members);

  3123 			free(t->enumeration);

  3124 		}

  3125 		break;

  3126 	case TYPE_base:

  3127 	case TYPE_pointer:

  3128 	case TYPE_void:

  3129 	case TYPE_reference:

  3130 		break; // nothing to do

  3131 	}

  3132 }

  3133 

  3134 void elfCleanUp(CompileUnit *comp)

  3135 {

  3136 	elfCleanUp(comp->abbrevs);

  3137 	free(comp->abbrevs);

  3138 	Function *func = comp->functions;

  3139 	while (func)

  3140 	{

  3141 		elfCleanUp(func);

  3142 		Function *next = func->next;

  3143 		free(func);

  3144 		func = next;

  3145 	}

  3146 	Type *t = comp->types;

  3147 	while (t)

  3148 	{

  3149 		elfCleanUp(t);

  3150 		Type *next = t->next;

  3151 		free(t);

  3152 		t = next;

  3153 	}

  3154 	Object *o = comp->variables;

  3155 	while (o)

  3156 	{

  3157 		elfCleanUp(o);

  3158 		Object *next = o->next;

  3159 		free(o);

  3160 		o = next;

  3161 	}

  3162 	if (comp->lineInfoTable)

  3163 	{

  3164 		free(comp->lineInfoTable->lines);

  3165 		free(comp->lineInfoTable->files);

  3166 		free(comp->lineInfoTable);

  3167 	}

  3168 }

  3169 

  3170 void elfCleanUp()

  3171 {

  3172 	CompileUnit *comp = elfCompileUnits;

  3173 

  3174 	while (comp)

  3175 	{

  3176 		elfCleanUp(comp);

  3177 		CompileUnit *next = comp->next;

  3178 		free(comp);

  3179 		comp = next;

  3180 	}

  3181 	elfCompileUnits = NULL;

  3182 	free(elfSymbols);

  3183 	elfSymbols = NULL;

  3184 	//  free(elfSymbolsStrTab);

  3185 	elfSymbolsStrTab = NULL;

  3186 

  3187 	elfDebugStrings = NULL;

  3188 	if (elfDebugInfo)

  3189 	{

  3190 		int num = elfDebugInfo->numRanges;

  3191 		int i;

  3192 		for (i = 0; i < num; i++)

  3193 		{

  3194 			free(elfDebugInfo->ranges[i].ranges);

  3195 		}

  3196 		free(elfDebugInfo->ranges);

  3197 		free(elfDebugInfo);

  3198 		elfDebugInfo = NULL;

  3199 	}

  3200 

  3201 	if (elfFdes)

  3202 	{

  3203 		if (elfFdeCount)

  3204 		{

  3205 			for (int i = 0; i < elfFdeCount; i++)

  3206 				free(elfFdes[i]);

  3207 		}

  3208 		free(elfFdes);

  3209 

  3210 		elfFdes     = NULL;

  3211 		elfFdeCount = 0;

  3212 	}

  3213 

  3214 	ELFcie *cie = elfCies;

  3215 	while (cie)

  3216 	{

  3217 		ELFcie *next = cie->next;

  3218 		free(cie);

  3219 		cie = next;

  3220 	}

  3221 	elfCies = NULL;

  3222 

  3223 	if (elfFileData)

  3224 	{

  3225 		free(elfFileData);

  3226 		elfFileData = NULL;

  3227 	}

  3228 }

  3229
author	Robert McIntyre <rlm@mit.edu>
date	Sat, 01 Sep 2012 04:15:32 -0500
parents	f9f4f1b99eed
children