/* dos.c
 * This file is part of Decomp - a disassembler.  In this file are
 * routines for handling various types of DOS/Win32 executable types
 * i.e. PE, NE, MZ, and COM.
 *
 * Copyright (C) 2001 Jonathan duSaint <dusaint@earthlink.net>
 *
 * Started early Feb 2002.
 */


/* not implemented yet */


#include <stdio.h>
#include <string.h>

#include "decomp.h"

/* various defines for dos/win files */
#include "dos.h"


/*  void */
/*  com_get_file_info (struct file_info *fi) */
/*  { */

/*  } */


/* MZ (legacy DOS executable) section */
void
mz_get_file_info (struct file_info *fi)
{

}
char *
mz_read_strtab (struct file_info *fi)
{
  return NULL;
}

struct symtab *
mz_get_next_symbol (struct file_info *fi, char *strtab)
{
  return NULL;
}


/* NE (Win16 New Executable) section */

void
read_ne_header (struct ne_file_header *nh, FILE *fp)
{
  d_read (nh->Signature, sizeof (char), 2, fp, 1);
  d_read (&nh->LinkerMajorVersion, sizeof (BYTE), 1, fp, 0);
  d_read (&nh->LinkerMinorVersion, sizeof (BYTE), 1, fp, 0);
  d_read (&nh->EntryTableOffset, sizeof (WORD), 1, fp, 0);
  d_read (&nh->EntryTableSize, sizeof (WORD), 1, fp, 0);
  d_read (nh->Reserved, sizeof (BYTE), 4, fp, 1);
  d_read (&nh->Flags, sizeof (WORD), 1, fp, 0);
  d_read (&nh->AutoDataSegment, sizeof (WORD), 1, fp, 0);
  d_read (&nh->HeapSize, sizeof (WORD), 1, fp, 0);
  d_read (&nh->StackSize, sizeof (WORD), 1, fp, 0);
  d_read (&nh->CS, sizeof (WORD), 1, fp, 0);
  d_read (&nh->IP, sizeof (WORD), 1, fp, 0);
  d_read (&nh->SS, sizeof (WORD), 1, fp, 0);
  d_read (&nh->SP, sizeof (WORD), 1, fp, 0);
  d_read (&nh->SegmentTableEntries, sizeof (WORD), 1, fp, 0);
  d_read (&nh->ModuleRefTableEntries, sizeof (WORD), 1, fp, 0);
  d_read (&nh->NonresidentNameTableSize, sizeof (WORD), 1, fp, 0);
  d_read (&nh->SegmentTableOffset, sizeof (WORD), 1, fp, 0);
  d_read (&nh->ResourceTableOffset, sizeof (WORD), 1, fp, 0);
  d_read (&nh->ResidentNameTableOffset, sizeof (WORD), 1, fp, 0);
  d_read (&nh->ModuleReferenceTableOffset, sizeof (WORD), 1, fp, 0);
  d_read (&nh->ImportedNameTableOffset, sizeof (WORD), 1, fp, 0);
  d_read (&nh->NonresidentNameTableOffset, sizeof (WORD), 1, fp, 0);
  d_read (&nh->MovableEntryPoints, sizeof (WORD), 1, fp, 0);
  d_read (&nh->Alignment, sizeof (WORD), 1, fp, 0);
  d_read (&nh->ResourceSegments, sizeof (WORD), 1, fp, 0);
  d_read (&nh->OperatingSystem, sizeof (BYTE), 1, fp, 0);
  d_read (&nh->AdditionalInformation, sizeof (BYTE), 1, fp, 0);
  d_read (&nh->FastLoadSectorOffset, sizeof (WORD), 1, fp, 0);
  d_read (&nh->FastLoadSectorSize, sizeof (WORD), 1, fp, 0);
  d_read (&nh->Reserved1, sizeof (WORD), 1, fp, 0);
  d_read (&nh->WindowsVersion, sizeof (WORD), 1, fp, 0);
}

void
ne_read_segment_header (struct ne_segment_header *sh, FILE *fp)
{
  d_read (&sh->SegmentDataSectorOffset, sizeof (WORD), 1, fp, 0);
  d_read (&sh->SegmentLength, sizeof (WORD), 1, fp, 0);
  d_read (&sh->Flags, sizeof (WORD), 1, fp, 0);
  d_read (&sh->AllocationSize, sizeof (WORD), 1, fp, 0);
}

void
ne_get_file_info (struct file_info *fi)
{
  int k, n_code = 0, n_data = 0;
  WORD ne_header_pos, sector_size;
  DWORD addr;
  struct ne_file_header nh;

  fi->bit_size = BS_16;
  fi->arch = MT_IA32;
  fi->endian = BO_LITTLE_ENDIAN;


  /* position at NE header */
  fseek (fi->fp, NE_POS_HEADER_OFFSET, SEEK_SET);
  d_read (&ne_header_pos, sizeof (WORD), 1, fi->fp, 0);
  fseek (fi->fp, ne_header_pos, SEEK_SET);


  read_ne_header (&nh, fi->fp);


  addr = fi->load_address = NE_MAKE_REAL_ADDRESS (nh.CS, nh.IP);
  sector_size = 1 << nh.Alignment;

  fi->data_sections = xmalloc ((nh.SegmentTableEntries + 1)
			       * sizeof (struct section_info *));
  fi->code_sections = xmalloc ((nh.SegmentTableEntries + 1)
			       * sizeof (struct section_info *));

  fseek (fi->fp, ne_header_pos + nh.SegmentTableOffset, SEEK_SET);

  for (k = 0; k < nh.SegmentTableEntries; k++)
    {
      char *section_name;
      WORD segment_size, loaded_segment_size;
      char *flags;
      struct ne_segment_header sh;

      ne_read_segment_header (&sh, fi->fp);

      /* NE doesn't have section names, so we create an arbitrary name */
      section_name = xmalloc (18);

      segment_size = sh.SegmentLength ? sh.SegmentLength : 0xffff;
      loaded_segment_size = sh.AllocationSize ? sh.AllocationSize : 0xffff;

      flags = "";

      if (NE_DATA_SEGMENT (sh.Flags))
	{
	  snprintf (section_name, 18, ".dataSection%d", n_data);

	  if (debug)
	    printf ("read data segment, idx %#x, offset %#x, size %#x\n", k,
		    sh.SegmentDataSectorOffset * sector_size, segment_size);

	  fi->data_sections[n_data] = alloc_section_info (section_name,
							  DATA_SECTION,
							  sh.SegmentDataSectorOffset * sector_size,
							  segment_size,
							  0, k, addr,
							  NULL, flags,
							  nh.Alignment);

	  put_data_limits (addr, addr + loaded_segment_size);
	  n_data++;
	}
      else if (NE_CODE_SEGMENT (sh.Flags))
	{
	  snprintf (section_name, 18, ".codeSection%d", n_code);

	  if (debug)
	    printf ("read code segment, idx %#x, offset %#x, size %#x\n", k,
		    sh.SegmentDataSectorOffset * sector_size, segment_size);

	  fi->code_sections[n_code] = alloc_section_info (section_name,
							  CODE_SECTION,
							  sh.SegmentDataSectorOffset * sector_size,
							  segment_size,
							  0, k, addr,
							  NULL, flags,
							  nh.Alignment);

	  n_code++;
	}

      /* guess start address of next section */
      addr = ((addr >> nh.Alignment) + 1) << nh.Alignment;
    }
/*    struct section_info *symtab; */
  fi->symtab = NULL;
/*    struct section_info *strtab; */
  fi->strtab = NULL;
}

char *
ne_read_strtab (struct file_info *fi)
{
  return NULL;
}

struct symtab *
ne_get_next_symbol (struct file_info *fi, char *strtab)
{
  return NULL;
}


/* PE (Win32 Portable Executable) section */

char *pe_flags[] = {
  "",          /* no flags */
  ", \"w\"",   /* writeable */
  ", \"x\"",   /* executable */
  ", \"xw\"",  /* executable and writeable */
};

char *
pe_get_flags (DWORD flags)
{
  int index = 0;

  index |= ((flags & IMAGE_SCN_MEM_WRITE) ? 1 : 0);
  index |= ((flags & IMAGE_SCN_MEM_EXECUTE) ? 2 : 0);

  return pe_flags[index];
}

int
pe_get_align (DWORD flags)
{
  return 1 << (((flags >> 20) & 0xf) - 1);
}


void
read_pe_header (PCOFF_HEADER ch, FILE *fp)
{
  d_read (&ch->PeSignature, sizeof (char), 4, fp, 1);
  d_read (&ch->Machine, sizeof (WORD), 1, fp, 0);
  d_read (&ch->NumberOfSections, sizeof (WORD), 1, fp, 0);
  d_read (&ch->TimeDateStamp, sizeof (DWORD), 1, fp, 0);
  d_read (&ch->PointerToSymbolTable, sizeof (DWORD), 1, fp, 0);
  d_read (&ch->NumberOfSymbols, sizeof (DWORD), 1, fp, 0);
  d_read (&ch->SizeOfOptionalHeader, sizeof (WORD), 1, fp, 0);
  d_read (&ch->Characteristics, sizeof (WORD), 1, fp, 0);
}

void
read_pe_optional_header (PPE32_OPTIONAL_HEADER oh, FILE *fp, WORD oh_size)
{
  WORD size = 0;

  d_read (&oh->Magic, sizeof (WORD), 1, fp, 0);
  size += sizeof (WORD);

  d_read (&oh->MajorLinkerVersion, sizeof (BYTE), 1, fp, 0);
  size += sizeof (BYTE);

  d_read (&oh->MinorLinkerVersion, sizeof (BYTE), 1, fp, 0);
  size += sizeof (BYTE);

  d_read (&oh->SizeOfCode, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);

  d_read (&oh->SizeOfInitializedData, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);

  d_read (&oh->SizeOfUninitializedData, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);

  d_read (&oh->AddressOfEntryPoint, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);

  d_read (&oh->BaseOfCode, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);

  if (oh->Magic == PE32_MAGIC)
    {
      d_read (&oh->BaseOfData, sizeof (DWORD), 1, fp, 0);
      size += sizeof (DWORD);
    }
  else
    oh->BaseOfData = 0;

  if (oh->Magic == PE32_MAGIC)
    {
      d_read (&oh->ImageBase, sizeof (DWORD), 1, fp, 0);
      size += sizeof (DWORD);
    }
  else
    {
      QWORD temp;

      d_read (&temp, sizeof (QWORD), 1, fp, 0);
      size += sizeof (QWORD);

      oh->ImageBase = (DWORD) temp;
    }

  d_read (&oh->SectionAlignment, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);

  d_read (&oh->FileAlignment, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);

  d_read (&oh->MajorOperatingSystemVersion, sizeof (WORD), 1, fp, 0);
  size += sizeof (WORD);

  d_read (&oh->MinorOperatingSystemVersion, sizeof (WORD), 1, fp, 0);
  size += sizeof (WORD);

  d_read (&oh->MajorImageVersion, sizeof (WORD), 1, fp, 0);
  size += sizeof (WORD);

  d_read (&oh->MinorImageVersion, sizeof (WORD), 1, fp, 0);
  size += sizeof (WORD);

  d_read (&oh->MajorSubsystemVersion, sizeof (WORD), 1, fp, 0);
  size += sizeof (WORD);

  d_read (&oh->MinorSubsystemVersion, sizeof (WORD), 1, fp, 0);
  size += sizeof (WORD);

  d_read (&oh->Reserved, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);

  d_read (&oh->SizeOfImage, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);

  d_read (&oh->SizeOfHeaders, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);

  d_read (&oh->CheckSum, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);

  d_read (&oh->Subsystem, sizeof (WORD), 1, fp, 0);
  size += sizeof (WORD);

  d_read (&oh->DLLCharacteristics, sizeof (WORD), 1, fp, 0);
  size += sizeof (WORD);

  if (oh->Magic == PE32_MAGIC)
    {
      d_read (&oh->SizeOfStackReserve, sizeof (DWORD), 1, fp, 0);
      size += sizeof (DWORD);
    }
  else
    {
      QWORD temp;

      d_read (&temp, sizeof (QWORD), 1, fp, 0);
      size += sizeof (QWORD);

      oh->SizeOfStackReserve = (DWORD) temp;
    }

  if (oh->Magic == PE32_MAGIC)
    {
      d_read (&oh->SizeOfStackCommit, sizeof (DWORD), 1, fp, 0);
      size += sizeof (DWORD);
    }
  else
    {
      QWORD temp;

      d_read (&temp, sizeof (QWORD), 1, fp, 0);
      size += sizeof (QWORD);

      oh->SizeOfStackCommit = (DWORD) temp;
    }

  if (oh->Magic == PE32_MAGIC)
    {
      d_read (&oh->SizeOfHeapReserve, sizeof (DWORD), 1, fp, 0);
      size += sizeof (DWORD);
    }
  else
    {
      QWORD temp;

      d_read (&temp, sizeof (QWORD), 1, fp, 0);
      size += sizeof (QWORD);

      oh->SizeOfHeapReserve = (DWORD) temp;
    }

  if (oh->Magic == PE32_MAGIC)
    {
      d_read (&oh->SizeOfHeapCommit, sizeof (DWORD), 1, fp, 0);
      size += sizeof (DWORD);
    }
  else
    {
      QWORD temp;

      d_read (&temp, sizeof (QWORD), 1, fp, 0);
      size += sizeof (QWORD);

      oh->SizeOfHeapCommit = (DWORD) temp;
    }

  d_read (&oh->LoaderFlags, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);

  d_read (&oh->NumberOfRvaAndSizes, sizeof (DWORD), 1, fp, 0);
  size += sizeof (DWORD);
}

void
read_oh_data_directories (IMAGE_DATA_DIRECTORY idd[N_OHDD], FILE *fp,
			  DWORD n_dd)
{
  int k;

  for (k = 0; k < n_dd; k++)
    {
      d_read (&idd[k].RVA, sizeof (DWORD), 1, fp, 0);
      d_read (&idd[k].Size, sizeof (DWORD), 1, fp, 0);
    }
}

void
read_pe_section_header (PSECTION_HEADER sh, FILE *fp)
{
  d_read (sh->Name, sizeof (char), 8, fp, 1);
  d_read (&sh->VirtualSize, sizeof (DWORD), 1, fp, 0);
  d_read (&sh->VirtualAddress, sizeof (DWORD), 1, fp, 0);
  d_read (&sh->SizeOfRawData, sizeof (DWORD), 1, fp, 0);
  d_read (&sh->PointerToRawData, sizeof (DWORD), 1, fp, 0);
  d_read (&sh->PointerToRelocations, sizeof (DWORD), 1, fp, 0);
  d_read (&sh->PointerToLinenumbers, sizeof (DWORD), 1, fp, 0);
  d_read (&sh->NumberOfRelocations, sizeof (WORD), 1, fp, 0);
  d_read (&sh->NumberOfLinenumbers, sizeof (WORD), 1, fp, 0);
  d_read (&sh->Characteristics, sizeof (DWORD), 1, fp, 0);
}

char *
get_pe_name (char *raw_name)
{
  char *name;
  int count;

  for (count = 0; count < 8; count++)
    if (!raw_name[count]) break;

  name = xmalloc (count + 1);
  memcpy (name, raw_name, count);

  return name;
}


void
pe_get_file_info (struct file_info *fi)
{
  int n_code = 0, n_data = 0, k;
  char *section_name;
  DWORD pe_header_location;
  COFF_HEADER ch;
  PE32_OPTIONAL_HEADER oh;
  SECTION_HEADER sh;
  IMAGE_DATA_DIRECTORY idd[N_OHDD];


  /* find the PE header */
  fseek (fi->fp, PE_HEADER_OFFSET, SEEK_SET);
  d_read (&pe_header_location, sizeof (DWORD), 1, fi->fp, 0);
  fseek (fi->fp, pe_header_location, SEEK_SET);


  read_pe_header (&ch, fi->fp);


  switch (ch.Machine)
    {
    case IMAGE_FILE_MACHINE_ALPHA:
      fi->arch = MT_ALPHA;
      break;
    case IMAGE_FILE_MACHINE_I386:
      fi->arch = MT_IA32;
      break;
    default:
      fi->arch = MT_UNK;
    }


  if (ch.Characteristics & IMAGE_FILE_BYTES_REVERSED_LO)
    fi->endian = BO_LITTLE_ENDIAN;
  else if (ch.Characteristics & IMAGE_FILE_BYTES_REVERSED_HI)
    fi->endian = BO_BIG_ENDIAN;

  if (ch.Characteristics & IMAGE_FILE_32BIT_MACHINE)
    fi->bit_size = BS_32;
  else if (ch.Characteristics & IMAGE_FILE_16BIT_MACHINE) /* won't see this */
    fi->bit_size = BS_16;
  else
    fi->bit_size = BS_64;


  /* handle symbol table and string table */
  if (ch.PointerToSymbolTable)
    {
      long file_pos;
      uint32_t strtab_size;

      fi->symtab = alloc_section_info (".symtab", OTHER_SECTION,
				       ch.PointerToSymbolTable,
				       ch.NumberOfSymbols * SIZE_SYMBOL_TABLE,
				       SIZE_SYMBOL_TABLE, 0, 0, NULL,
				       NULL, 0);

      /* read the size of the string table */
      file_pos = ftell (fi->fp);
      fseek (fi->fp, (ch.PointerToSymbolTable + (ch.NumberOfSymbols
						 * SIZE_SYMBOL_TABLE)),
	     SEEK_SET);
      d_read (&strtab_size, sizeof (uint32_t), 1, fi->fp, 0);
      fseek (fi->fp, file_pos, SEEK_SET);

      strtab_size -= 4;

      fi->strtab = alloc_section_info (".strtab", STRING_SECTION,
				       (ch.PointerToSymbolTable
					+ (ch.NumberOfSymbols
					   * SIZE_SYMBOL_TABLE)) + 4,
				       strtab_size, 0, 0, 0, NULL, NULL, 0);
    }


  oh.NumberOfRvaAndSizes = 0;

  read_pe_optional_header (&oh, fi->fp, ch.SizeOfOptionalHeader);
  read_oh_data_directories (idd, fi->fp, oh.NumberOfRvaAndSizes);


  /* find load address */
  fi->load_address = oh.ImageBase + oh.AddressOfEntryPoint;


  /* should be pointing at the section headers here */
  fi->data_sections = xmalloc ((ch.NumberOfSections + 1)
			       * sizeof (struct section_info));
  fi->code_sections = xmalloc ((ch.NumberOfSections + 1)
			       * sizeof (struct section_info));

  for (k = 1; k < ch.NumberOfSections + 1; k++)
    {
      read_pe_section_header (&sh, fi->fp);

      section_name = get_pe_name (sh.Name);

      if (debug)
	printf ("read %s, idx %#x, offset %#x\n", section_name, k,
		sh.PointerToRawData);


      if (sh.Characteristics & IMAGE_SCN_CNT_CODE) /* code section */
	{
	  fi->code_sections[n_code] = alloc_section_info (section_name,
							  CODE_SECTION,
							  sh.PointerToRawData,
							  sh.SizeOfRawData,
							  0, k,
							  oh.ImageBase
							  + sh.VirtualAddress,
							  NULL,
							  pe_get_flags (sh.Characteristics),
							  pe_get_align (sh.Characteristics));

	  n_code++;

	  put_data_limits (oh.ImageBase + sh.VirtualAddress,
			   oh.ImageBase + sh.VirtualAddress + sh.VirtualSize);
	}
      else if (sh.Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA
	       || sh.Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
	{
	  

	  fi->data_sections[n_data] = alloc_section_info (section_name,
							  DATA_SECTION,
							  sh.PointerToRawData,
							  sh.SizeOfRawData,
							  0, k,
							  oh.ImageBase
							  + sh.VirtualAddress,
							  NULL,
							  pe_get_flags (sh.Characteristics),
							  pe_get_align (sh.Characteristics));

	  n_data++;

	  put_data_limits (oh.ImageBase + sh.VirtualAddress,
			   oh.ImageBase + sh.VirtualAddress + sh.VirtualSize);
	}
      else /* not sure what this section could be */
	{
	  if (debug)
	    printf ("unknown section: %s, flags: %08X\n", section_name,
		    sh.Characteristics);

	  xfree (section_name);
	}
    }



  /* print debug info */
  if (debug)
    {
      k = -1;
      printf ("data:\n");
      while (fi->data_sections[++k])
	{
	  printf ("  %s (%#lx), %d, %#lx, %#lx, %#lx\n",
		  fi->data_sections[k]->section_name,
		  fi->data_sections[k]->section_index,
		  fi->data_sections[k]->section_type,
		  fi->data_sections[k]->section_offset,
		  fi->data_sections[k]->section_size,
		  fi->data_sections[k]->load_address);
	}

      k = -1;
      printf ("code:\n");
      while (fi->code_sections[++k])
	{
	  printf ("  %s (%#lx), %d, %#lx, %#lx, %#lx\n",
		  fi->code_sections[k]->section_name,
		  fi->code_sections[k]->section_index,
		  fi->code_sections[k]->section_type,
		  fi->code_sections[k]->section_offset,
		  fi->code_sections[k]->section_size,
		  fi->code_sections[k]->load_address);
	}

      if (fi->symtab != NULL)
	printf ("symtab:\n  %s (%#lx), %d, %#lx, %#lx, %#lx\n",
		fi->symtab->section_name,
		fi->symtab->section_index,
		fi->symtab->section_type,
		fi->symtab->section_offset,
		fi->symtab->section_size,
		fi->symtab->load_address);

      if (fi->strtab != NULL)
	printf ("strtab:\n  %s (%#lx), %d, %#lx, %#lx, %#lx\n",
		fi->strtab->section_name,
		fi->strtab->section_index,
		fi->strtab->section_type,
		fi->strtab->section_offset,
		fi->strtab->section_size,
		fi->strtab->load_address);
    }
}


char *
pe_read_strtab (struct file_info *fi)
{
  char *strtab;

  if (fi->strtab == NULL) return NULL;

  fseek (fi->fp, fi->strtab->section_offset, SEEK_SET);

  strtab = xmalloc (fi->strtab->section_size);

  d_read (strtab, sizeof (char), fi->strtab->section_size, fi->fp, 1);

  return strtab;
}


/* pe_read_symbol
 * Read a symbol from the symbol table.
 */
void
pe_read_symbol (PCOFF_SYMBOL_TABLE sym, FILE *fp)
{
  DWORD temp;

  d_read (&temp, sizeof (DWORD), 1, fp, 0);
  fseek (fp, -4, SEEK_CUR);

  if (temp != 0)
    d_read (sym->Name.ShortName, sizeof (char), 8, fp, 1);
  else
    {
      d_read (&sym->Name.LongName.Zeroes, sizeof (DWORD), 1, fp, 0);
      d_read (&sym->Name.LongName.Offset, sizeof (DWORD), 1, fp, 0);
    }

  d_read (&sym->Value, sizeof (DWORD), 1, fp, 0);
  d_read (&sym->SectionNumber, sizeof (WORD), 1, fp, 0);
  d_read (&sym->Type, sizeof (WORD), 1, fp, 0);
  d_read (&sym->StorageClass, sizeof (BYTE), 1, fp, 0);
  d_read (&sym->NumberOfAuxSymbols, sizeof (BYTE), 1, fp, 0);
}


/* pe_read_aux_format_one
 * Read in function definition information.
 */
void
pe_read_aux_format_one (PAUXILIARY_FORMAT_ONE af, FILE *fp)
{
  d_read (&af->TagIndex, sizeof (DWORD), 1, fp, 0);
  d_read (&af->TotalSize, sizeof (DWORD), 1, fp, 0);
  d_read (&af->PointerToLinenumber, sizeof (DWORD), 1, fp, 0);
  d_read (&af->PointerToNextFunction, sizeof (DWORD), 1, fp, 0);
  d_read (&af->Unused, sizeof (BYTE), 2, fp, 0);
}

/* pe_read_aux_format_two
 * Read in information on the .bf and .ef symbols.
 */
void
pe_read_aux_format_two (PAUXILIARY_FORMAT_TWO af, FILE *fp)
{
  d_read (&af->Unused1, sizeof (BYTE), 4, fp, 0);
  d_read (&af->Linenumber, sizeof (WORD), 1, fp, 0);
  d_read (&af->Unused2, sizeof (BYTE), 6, fp, 0);
  d_read (&af->PointerToNextFunction, sizeof (DWORD), 1, fp, 0);
  d_read (&af->Unused3, sizeof (BYTE), 2, fp, 0);
}

/* pe_read_aux_format_three
 * Read in information on weak external symbols.
 */
void
pe_read_aux_format_three (PAUXILIARY_FORMAT_THREE af, FILE *fp)
{
  d_read (&af->TagIndex, sizeof (DWORD), 1, fp, 0);
  d_read (&af->Characteristics, sizeof (DWORD), 1, fp, 0);
  d_read (&af->Unused, sizeof (BYTE), 10, fp, 0);
}

/* pe_read_aux_format_four
 * Read in information on a .file symbol.
 */
void
pe_read_aux_format_four (PAUXILIARY_FORMAT_FOUR af, FILE *fp)
{
  d_read (af->FileName, sizeof (char), 18, fp, 1);
}

/* pe_read_aux_format_five
 * Read in section definition information.
 */
void
pe_read_aux_format_five (PAUXILIARY_FORMAT_FIVE af, FILE *fp)
{
  d_read (&af->Length, sizeof (DWORD), 1, fp, 0);
  d_read (&af->NumberOfRelocations, sizeof (WORD), 1, fp, 0);
  d_read (&af->NumberOfLineNumbers, sizeof (WORD), 1, fp, 0);
  d_read (&af->CheckSum, sizeof (DWORD), 1, fp, 0);
  d_read (&af->Number, sizeof (WORD), 1, fp, 0);
  d_read (&af->Selection, sizeof (BYTE), 1, fp, 0);
  d_read (&af->Unused, sizeof (BYTE), 3, fp, 0);
}


enum symbol_type
pe_get_symbol_type (WORD type, BYTE class)
{
  if (((type >> 4) & 0xf) == IMAGE_SYM_DTYPE_FUNCTION) /* function */
    {
      if (class == IMAGE_SYM_CLASS_EXTERNAL)
	return GLOBAL_FUNCTION;
      else
	return LOCAL_FUNCTION;
    }
  else /* data */
    {
      if (class == IMAGE_SYM_CLASS_EXTERNAL)
	return GLOBAL_DATA;
      else
	return LOCAL_DATA;
    }

  return UNKNOWN_SYMBOL;
}


/* pe_get_next_symbol
 * Read in the next symbol from the symbol table and return
 * it as a struct symtab.
 */
struct symtab *
pe_get_next_symbol (struct file_info *fi, char *strtab)
{
  struct symtab *sym;
  COFF_SYMBOL_TABLE symbol;

  sym = xmalloc (sizeof (struct symtab));

  pe_read_symbol (&symbol, fi->fp);

  /* get the symbol name */
  if (symbol.Name.LongName.Zeroes != 0)
    sym->name = get_pe_name (symbol.Name.ShortName);
  else
    {
      sym->name = xmalloc (strlen (strtab + symbol.Name.LongName.Offset) + 1);
      strcpy (sym->name, strtab + symbol.Name.LongName.Offset);
    }

  sym->address = symbol.Value; /* most likely */

  if (symbol.SectionNumber < 1)
    {
      sym->address = 0;
      sym->idx = 0;
    }
  else
    sym->idx = symbol.SectionNumber;

  /* if this is an external or static symbol, the load address is
     the Value added to the load address of the section */
  if (symbol.StorageClass == IMAGE_SYM_CLASS_EXTERNAL
      || symbol.StorageClass == IMAGE_SYM_CLASS_STATIC)
    {
      if (symbol.SectionNumber > 0)
	{
	  /* need to find the section with the matching number */
	  int k;

	  for (k = 0; fi->code_sections[k] != NULL; k++)
	    if (fi->code_sections[k]->section_index == symbol.SectionNumber)
	      {
		sym->address = (fi->code_sections[k]->load_address
				+ symbol.Value);
		goto GOT_SECTION_NUMBER;
	      }

	  for (k = 0; fi->data_sections[k] != NULL; k++)
	    if (fi->data_sections[k]->section_index == symbol.SectionNumber)
	      sym->address = (fi->data_sections[k]->load_address
			      + symbol.Value);

	GOT_SECTION_NUMBER:
	  ;
	}
    }

  sym->type = pe_get_symbol_type (symbol.Type, symbol.StorageClass);

  switch (symbol.Type & 0xf)
    {
    case IMAGE_SYM_TYPE_CHAR:
    case IMAGE_SYM_TYPE_BYTE:
      sym->size = 1;
      break;
    case IMAGE_SYM_TYPE_SHORT:
      sym->size = 2;
      break;
    case IMAGE_SYM_TYPE_INT:
    case IMAGE_SYM_TYPE_LONG:
    case IMAGE_SYM_TYPE_FLOAT:
    case IMAGE_SYM_TYPE_UINT:
    case IMAGE_SYM_TYPE_DWORD:
      sym->size = 4;
      break;
    case IMAGE_SYM_TYPE_DOUBLE:
      sym->size = 8;
      break;
    default:
      sym->size = 0;
    }

  if (sym->size == 0 && ((symbol.Type >> 4) & 0xf) == IMAGE_SYM_DTYPE_POINTER)
    {
      if (fi->bit_size == BS_32)
	sym->size = 4;
      else if (fi->bit_size == BS_64)
	sym->size = 8;
    }

  /* auxiliary data isn't necessarily used */
  fseek (fi->fp, 18 * symbol.NumberOfAuxSymbols, SEEK_CUR);

  if (debug)
    printf ("%#lx:%s: size %lx, type %x, class %x, idx %lx\n", sym->address,
	    sym->name, sym->size, symbol.Type, symbol.StorageClass, sym->idx);

  return sym;
}