#include <sys/stat.h>

#include <elf.h>
#include <errno.h>
#include <fcntl.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <R4300.h>
#include <ramrom.h>

#include <leo.h>

#include "makedisk.h"

// Function prototypes for internal functions.
//
static int		sizeObject(Segment *);
static int		sizeRaw(Segment *);
static void *		lookupSymbol(Wave *, char *);
static int		openAouts(void);
static Elf32_Shdr	*lookupShdr(Wave *, char *);
static int		readObject(Segment *);
static int		readRaw(Segment *);

// Internal variables
//
static char *		romImage;   // Pointer to the accumulated rom image
static char *		diskImage;


static int		cryptRomBoot(Wave *);
static int 		getSymbolValue(char *name, unsigned long *value);
int			allRom = 1;	/* 1:all segments are in ROM, 0:otherwise */


extern int  byte2LBA(int, int, int);
extern int  lba2Byte(int, int, int);


////////////////////////////////////////////////////////////////////////////////
// scanSegments()
//
// For each segment in a spec file,
//   Examine the segment and compute the important information about it.
//   This info includes size, its "after" status, and sometimes the
//     alignment.  
//   Keep a running total of the size, and at the end malloc() all the
//     space which should be necessary for the ROM image.
//
int scanSegments(void) {
    Segment *s;
    unsigned int romOffset = SizeofEntryRoutine;  // size of ROM image.
    int rom_size;
    unsigned int diskOffset;  // size of disk image.
    int disk_size;

    if (cartBoot)
    {
	/*
	 * 今回コンパイルするもののディスク部分にはブートセグメントはない。
	 * (ディスクには必ずあるが、それは別コンパイル)
	 */
	diskOffset = 0;
    }
    else
    {
	diskOffset = SizeofEntryRoutine;
    }

    // Check to be sure ELF version is current
    //
    if (elf_version(EV_CURRENT) == EV_NONE) {
	fprintf(stderr, "makedisk: out of date\n");
	return(-1);
    }

    // For each segment in the spec file
    //
    for (s = segmentList; s != NULL; s = s->next) {
	
	// Check to make sure the segment is in a wave.
	if (s->wave == (Wave *)NULL) {
	    fprintf(stderr,
		    "makedisk: segment \"%s\": not found in any wave\n",
		    s->name);
	    return(-1);
	}
	
	s->romOffset = romOffset;
	s->diskOffset = diskOffset;
	
	// Get size of segment's sections, depending on OBJECT or RAW
	if (s->flags & SEGFLAG_OBJECT) {
	    if (sizeObject(s) == -1)
		return(-1);
	} else if (s->flags & SEGFLAG_RAW) {
	    if (sizeRaw(s) == -1)
		return(-1);
	}
	
	// In case this value was altered (boot segment does this!) we need
	//   to re-set this value.
	romOffset = s->romOffset;
	diskOffset = s->diskOffset;

	// This computes the amount of space this needs to take up on 
	//   the ROM.  That's why it is only text, data, and sdata.
	// This can ignore the alignment issues in code space.

	if (s->media == MEDIA_CART)
	{
	    romOffset += (s->textSize + s->dataSize + s->sdataSize);
	    romOffset = ALIGNn(16, romOffset);
	}
	else
	{

	    diskOffset += (s->textSize + s->dataSize + s->sdataSize);
	    diskOffset = ALIGNn(16, diskOffset);

	    if (s->afterDisk != 0)
	    {

		s->startLba = s->afterDisk->startLba +
		    s->afterDisk->sizeInLba;
	    }
	    
	    if (s->flags & SEGFLAG_BOOT)
	    {
		s->sizeInLba = byte2LBA(disktype, s->startLba, 
					s->diskOffset + s->textSize +
					s->dataSize + s->sdataSize);
	    }
	    else 
	    {
		if ( (s->textSize + s->dataSize + s->sdataSize == 0) &&
		    (s->startLba != -1) )
		{
		    fprintf(stderr, "makedisk: WARNING: rom size of segment \"%s\" is 0 "
			    "but lba is specified in spec file\n", s->name);
		    s->sizeInLba = 0;

		} else if ( (s->textSize + s->dataSize + s->sdataSize > 0) &&
			   (s->startLba != -1) )
		{
		    s->sizeInLba = byte2LBA(disktype, s->startLba, 
					    s->textSize + s->dataSize +
					    s->sdataSize);

		} else if ( (s->textSize + s->dataSize + s->sdataSize > 0) &&
			   (s->startLba == -1) )
		{
		    fprintf(stderr, "makedisk: start lba is not specified for segment \"%s\"\n", s->name);
		    return(-1);

		} else if ( (s->textSize + s->dataSize + s->sdataSize == 0) &&
			   (s->startLba == -1) )
		{
		    s->sizeInLba = 0;
		}
		
	    }

	} /* if (media == cart) */
    }
    
    // Ensure that rom size is at least as large as the entry routine
    rom_size = (romOffset > SizeofEntryRoutine) ? romOffset : SizeofEntryRoutine;
    disk_size = diskOffset;
    
    if (cartBoot)
    {
	/*
	 * Malloc the rom size that we need!!
	 * Changed this to a calloc so that rom image would be zeroed
	 * unless data was written into it.
	 */
	romImage = (char*) calloc(rom_size,1);
	
	/*
	 * Fixed by yasu@rd3.nintendo.co.jp
	 * Check to make sure malloc did not fail.
	 */
	if (NULL == romImage){
	    fprintf(stderr, "makedisk: malloc failed [RomSize= %d kB]\n",
		    (rom_size + 1023) / 1024);
	    return(-1);
	}
    }
    
    // Malloc the disk size that we need!!
    // Changed this to a calloc so that disk image would be zeroed
    //   unless data was written into it.
    diskImage = (char*) calloc(disk_size,1);
    
    // Fixed by yasu@rd3.nintendo.co.jp */
    // Check to make sure malloc did not fail.
    if (NULL == diskImage){
	fprintf(stderr, "makedisk: malloc failed [DiskSize= %d kB]\n",
		(disk_size + 1023) / 1024);
	return(-1);
    }

    return(0);
}



////////////////////////////////////////////////////////////////////////////////
// sizeObject()
//
// For each file listed in a segment,
//   Examine each section in the file.
//   For particular sections, record the important information about the
//     section.  This important info is usually just size, but sometimes 
//     alignment is also important.
//
static int sizeObject(Segment *s) {
    unsigned int address1, address2;
    int fd;
    Elf *elf;
    Elf_Scn *scn;
    Elf32_Ehdr *ehdr;
    Elf32_Shdr *shdr;
    Path *p;
    size_t index;
    char *sectName;
    int currAddress;
    int firstSection = 1;

    // Initialize this segment's alignment
    // Minimum is 16B alignment.
    s->textAlign = 16;

    // Print out some useful debug info
    //
    if (debug) {
	if ((s->align != 16) && (s->align != 0))
	    printf("Segment %s: alignment %x\n", s->name, s->align);
    }

    // For each file in the segment
    for (p = s->pathList; p != NULL; p = p->next) {

	// Initialize values
	p->textSize = 0;
	p->dataSize = 0;
	p->sdataSize = 0;
	p->sbssSize = 0;
	p->bssSize = 0;
	p->textAlign = 0;
	p->dataAlign = 0;
	p->sdataAlign = 0;
	p->sbssAlign = 0;
	p->bssAlign = 0;

	// Open the file
	if ((fd = open(p->name, O_RDONLY)) == -1) {
	    fprintf(stderr,
		    "makedisk: %s: %s\n",
		    p->name, sys_errlist[errno]);
	    return(-1);
	}
	if (debug)
	    printf("Scanning %s\n", p->name);
	elf = elf_begin(fd, ELF_C_READ, (Elf *)NULL);
	if ((elf_kind(elf) != ELF_K_ELF) ||
	    ((ehdr = elf32_getehdr(elf)) == NULL)) {
	    fprintf(stderr,
		    "makedisk: %s: not a valid ELF object file\n", p->name);
	    return(-1);
	}

	// For each section in the file
	for (index = 1; index < ehdr->e_shnum; index++) {
	    if (((scn = elf_getscn(elf, index)) == NULL) ||
		((shdr = elf32_getshdr(scn)) == NULL)) {
		fprintf(stderr,
			"makedisk: %s: can't get section index %d\n",
			p->name, index);
		return(-1);
	    }
	    sectName = elf_strptr(elf, ehdr->e_shstrndx,
				  (size_t)shdr->sh_name);
	    
	    if (NULL == sectName){
		fprintf(stderr,
			"makedisk: %s: detect unnamed section\n", p->name);
		return(-1);
	    }

	    // Examine and record sizes and characteristics of each particular 
	    //   section in the file.
	    //
	    // As we go through these files, we record the maximum alignment
	    //   in each section in the s->*Align variable.
	    if (strcmp(sectName, ELF_TEXT) == 0) {                    // .text
		s->textSize += shdr->sh_size;
		p->textAlign = shdr->sh_addralign;
		p->textSize = shdr->sh_size;
		p->sectionsExisting |= TEXT_EXISTS;
		s->sectionsExisting |= TEXT_EXISTS;
		if (p->textAlign > s->textAlign)
		    s->textAlign = p->textAlign;
		if (debug) {
		    printf("  text size  = %x\n", shdr->sh_size);
		    printf("       align = %x\n", shdr->sh_addralign);
		}
	    } else if ((strcmp(sectName, ELF_DATA) == 0) ||       // .data & .rodata
		       (strcmp(sectName, ELF_RODATA) == 0)) {
		s->dataSize += shdr->sh_size;
		p->dataAlign = shdr->sh_addralign;
		p->dataSize += shdr->sh_size;
		p->sectionsExisting |= DATA_EXISTS;
		s->sectionsExisting |= DATA_EXISTS;
		if (p->dataAlign > s->dataAlign)
		    s->dataAlign = p->dataAlign;
		if (debug) {
		    printf("  data&rodata size  = %x\n", shdr->sh_size);
		    printf("       align = %x\n", shdr->sh_addralign);
		}
	    } else if (strcmp(sectName, MIPS_SDATA) == 0) {           // .sdata
		s->sdataSize += shdr->sh_size;
		p->sdataAlign = shdr->sh_addralign;
		p->sdataSize = shdr->sh_size;
		s->sectionsExisting |= SDATA_EXISTS;
		p->sectionsExisting |= SDATA_EXISTS;
		if (p->sdataAlign > s->sdataAlign)
		    s->sdataAlign = p->sdataAlign;
		if (debug) {
		    printf("  sdata size  = %x\n", shdr->sh_size);
		    printf("        align = %x\n", shdr->sh_addralign);
		}
	    } else if (strcmp(sectName, MIPS_SBSS) == 0) {            // .sbss
		s->sbssSize += shdr->sh_size;
		p->sbssAlign = shdr->sh_addralign;
		p->sbssSize = shdr->sh_size;
		p->sectionsExisting |= SBSS_EXISTS;
		s->sectionsExisting |= SBSS_EXISTS;
		if (p->sbssAlign > s->sbssAlign)
		    s->sbssAlign = p->sbssAlign;
		if (debug) {
		    printf("  sbss size  = %x\n", shdr->sh_size);
		    printf("       align = %x\n", shdr->sh_addralign);
		}
	    } else if (strcmp(sectName, ELF_BSS) == 0) {              // .bss
		s->bssSize += shdr->sh_size;
		p->bssAlign = shdr->sh_addralign;
		p->bssSize = shdr->sh_size;
		p->sectionsExisting |= BSS_EXISTS;
		s->sectionsExisting |= BSS_EXISTS;
		if (p->bssAlign > s->bssAlign)
		    s->bssAlign = p->bssAlign;
		if (debug) {
		    printf("  bss size  = %x\n", shdr->sh_size);
		    printf("      align = %x\n", shdr->sh_addralign);
		}
	    }
	}
	close(fd);
    }

    // Now we need to know where this segment intends to start in memory.
    //
    switch (s->addrFunc) {
      case AFTERFUNC_MAX:
	address1 = s->afterSeg1->address + s->afterSeg1->totalSize;
	address2 = s->afterSeg2->address + s->afterSeg2->totalSize;
	currAddress = MAX(address1, address2);
	break;
      case AFTERFUNC_MIN:
	address1 = s->afterSeg1->address + s->afterSeg1->totalSize;
	address2 = s->afterSeg2->address + s->afterSeg2->totalSize;
	currAddress = MIN(address1, address2);
	break;
      case AFTERFUNC_UNARY:
	address1 = s->afterSeg1->address + s->afterSeg1->totalSize;
	currAddress = address1;
	break;
      case ADDRFUNC_ADDRESS:
	currAddress = s->address;
	break;
      case ADDRFUNC_SEGMENT:
	currAddress = s->address;
	break;
      default:
	break;
    }

    // This will align the top of the segment to some address specified
    //   in the spec file.  By default, if nothing was specified in spec,
    //   this value will be 16.
    currAddress = ALIGNn(s->align, currAddress);

    // Just in case there are no recognizable sections in this segment,
    //   we'll set up the starting address for this segment to be the
    //   address we're currently at.  That'll keep us from erroring out.
    s->address = currAddress;

    // This is IMPORTANT!  If the top address of this segment has been
    //   adjusted, and it is the boot segment, the top of the segment
    //   in the rom file must also be adjusted.  Otherwise, when the 
    //   first MB of the rom file is loaded into RDRAM, the entry point
    //   indicated by the boot stub will be incorrect!
    // Another addition: Be sure to align the boot segment in the rom
    //   by the align keyword if it is used!  This is important since the 
    //   first segment is DMA'd into RAM automatically at x400.
    if (s->flags & SEGFLAG_BOOT) {

	currAddress = ALIGNn(s->textAlign, currAddress);

	if (cartBoot)
	{
	    s->romOffset = ALIGNn(s->textAlign, s->romOffset);
	    s->romOffset = ALIGNn(s->align, s->romOffset);
	}
	else
	{
	    s->diskOffset = ALIGNn(s->textAlign, s->diskOffset);
	    s->diskOffset = ALIGNn(s->align, s->diskOffset);
	}
    }

    // Now loop through and do some address computation.
    //

    // Text sections
    if (s->sectionsExisting & TEXT_EXISTS) {
	// Align top of output section to max align of 
	//   text sections (in case > 16)
	currAddress = ALIGNn(s->textAlign, currAddress);
	s->textStart = currAddress;
	s->address = currAddress;
	firstSection = 0;

	for (p=s->pathList; p!=NULL; p=p->next) {
	    if (p->sectionsExisting & TEXT_EXISTS) {
		currAddress = ALIGNn(p->textAlign, currAddress);
		p->textStart = currAddress;
		currAddress += p->textSize;
	    }
	}
    } else {
	s->textStart = currAddress;
    }

    // Data sections
    if (s->sectionsExisting & DATA_EXISTS) {
	// Align top of output section to max align of 
	//   data sections (in case > 16)
	currAddress = ALIGNn(s->dataAlign, currAddress);
	s->dataStart = currAddress;
	if (firstSection) {
	    s->address = currAddress;
	    firstSection = 0;
	}
	for (p=s->pathList; p!=NULL; p=p->next) {
	    if (p->sectionsExisting & DATA_EXISTS) {
		currAddress = ALIGNn(p->dataAlign, currAddress);
		p->dataStart = currAddress;
		currAddress += p->dataSize;
	    }
	}
    } else {
	s->dataStart = currAddress;
    }

    // Sdata sections
    if (s->sectionsExisting & SDATA_EXISTS) {

	// Align top of output section to max align of 
	//   sdata sections (in case > 16)
	currAddress = ALIGNn(s->sdataAlign, currAddress);
	s->sdataStart = currAddress;
	if (firstSection) {
	    s->address = currAddress;
	    firstSection = 0;
	}
	for (p=s->pathList; p!=NULL; p=p->next) {
	    if (p->sectionsExisting & SDATA_EXISTS) {
		currAddress = ALIGNn(p->sdataAlign, currAddress);
		p->sdataStart = currAddress;
		currAddress += p->sdataSize;
	    }
	}
    } else {
	s->sdataStart = currAddress;
    }

    // Sbss sections
    if (s->sectionsExisting & SBSS_EXISTS) {

	// Align top of output section to max align of 
	//   sbss sections (in case > 16)
	currAddress = ALIGNn(s->sbssAlign, currAddress);
	s->sbssStart = currAddress;
	if (firstSection) {
	    s->address = currAddress;
	    firstSection = 0;
	}
	for (p=s->pathList; p!=NULL; p=p->next) {
	    if (p->sectionsExisting & SBSS_EXISTS) {
		currAddress = ALIGNn(p->sbssAlign, currAddress);
		p->sbssStart = currAddress;
		currAddress += p->sbssSize;
	    }
	}
    } else {
	s->sbssStart = currAddress;
    }

    // Bss sections
    if (s->sectionsExisting & BSS_EXISTS) {
	
	// Align top of output section to max align of 
	//   bss sections (in case > 16)
	currAddress = ALIGNn(s->bssAlign, currAddress);
	s->bssStart = currAddress;
	if (firstSection) {
	    s->address = currAddress;
	    firstSection = 0;
	}
	for (p=s->pathList; p!=NULL; p=p->next) {
	    if (p->sectionsExisting & BSS_EXISTS) {
		currAddress = ALIGNn(p->bssAlign, currAddress);
		p->bssStart = currAddress;
		currAddress += p->bssSize;
	    }
	}
    } else {
	s->bssStart = currAddress;
    }

    s->textSize  = s->dataStart - s->address;
    s->dataSize  = s->sdataStart - s->dataStart;
    s->sdataSize = s->sbssStart - s->sdataStart;
    s->sbssSize  = s->bssStart - s->sbssStart;
    s->bssSize   = currAddress - s->bssStart;

    s->totalSize = currAddress - s->address;

    return(0);
}


////////////////////////////////////////////////////////////////////////////////
// sizeRaw()
//
// For each file in the segment
//   Open the file and determine its size.  Add its size
//     to the totalSize for this segment.
//
static int sizeRaw(Segment *s) {
    unsigned int address1, address2;
    unsigned int currAddress;
    int		fd;
    Path		*p;
    struct stat	statBuffer;

    // Minimum data align value
    //
    s->dataAlign = 16;
    s->sectionsExisting = DATA_EXISTS;

    for (p = s->pathList; p != NULL; p = p->next) {

	// Initialize values
	p->textSize = 0;
	p->dataSize = 0;
	p->sdataSize = 0;
	p->sbssSize = 0;
	p->bssSize = 0;
	p->textAlign = 0;
	p->dataAlign = 16;
	p->sdataAlign = 0;
	p->sbssAlign = 0;
	p->bssAlign = 0;
	p->sectionsExisting = DATA_EXISTS;

	if ((fd = open(p->name, O_RDONLY)) == -1) {
	    fprintf(stderr,
		    "makedisk: %s: %s\n",
		    p->name, sys_errlist[errno]);
	    return(-1);
	}
	if (fstat(fd, &statBuffer) == -1) {
	    fprintf(stderr, "makedisk: lstat failed: %s\n",
		    sys_errlist[errno]);
	    return(-1);
	}
	s->dataSize  += statBuffer.st_size;

	close(fd);
    }

    // Align the data size to a multiple of 16B.
    s->totalSize = s->dataSize = ALIGN128(s->dataSize);

    // Now we need to know where this segment intends to start in memory.
    //
    switch (s->addrFunc) {
      case AFTERFUNC_MAX:
	address1 = s->afterSeg1->address + s->afterSeg1->totalSize;
	address2 = s->afterSeg2->address + s->afterSeg2->totalSize;
	currAddress = MAX(address1, address2);
	break;
      case AFTERFUNC_MIN:
	address1 = s->afterSeg1->address + s->afterSeg1->totalSize;
	address2 = s->afterSeg2->address + s->afterSeg2->totalSize;
	currAddress = MIN(address1, address2);
	break;
      case AFTERFUNC_UNARY:
	address1 = s->afterSeg1->address + s->afterSeg1->totalSize;
	currAddress = address1;
	break;
      case ADDRFUNC_ADDRESS:
	currAddress = s->address;
	break;
      case ADDRFUNC_SEGMENT:
	currAddress = s->address;
	break;
      default:
	break;
    }

    // This will align the top of the segment to some address specified
    //   in the spec file.  By default, if nothing was specified in spec,
    //   this value will be 16.
    currAddress = ALIGNn(s->align, currAddress);

    // NOTE: Since the file is never actually looked at for ELF info, we don't
    //   worry about the specified data alignment.  However, let's do an align
    //   by the default, anyway.
    currAddress = ALIGNn(s->dataAlign, currAddress);

    // Set the segment starting address to our "alignment-modified" version.
    s->address = currAddress;

    return(0);
}


////////////////////////////////////////////////////////////////////////////////
// checkSizes()
//
//
//
int checkSizes(void) {
    Segment *s;
    int sizeViolation = 0;
    
    allRom = 1;

    for (s = segmentList; s != NULL; s = s->next) {
	
	/*
	 * カートリッジ起動の場合のみ、ブートセグメントが 1M を超えてしまわ
	 * ないかのチェックをする。
	 */
	if ((s->flags & SEGFLAG_BOOT) &&
	    (cartBoot == 1) &&
	    ((s->textSize + s->dataSize + s->sdataSize) > MAX_BOOTSIZE)) {
	    fprintf(stderr,
		    "makedisk: segment \"%s\" (text+data) size ",
		    s->name);
	    fprintf(stderr, "(%d+%d) = %d (0x%x)\n         ",
		    s->textSize, s->dataSize + s->sdataSize,
		    s->textSize + s->dataSize + s->sdataSize,
		    s->textSize + s->dataSize + s->sdataSize);
	    fprintf(stderr,
		    "exceeds maximum BOOT segment size %d (0x%x)\n",
		    MAX_BOOTSIZE, MAX_BOOTSIZE);
	    sizeViolation = 1;
	}
	
	if (s->totalSize > s->maxSize) {
	    fprintf(stderr, "makedisk: segment \"%s\" (text+data+bss) size ",
		    s->name);
	    fprintf(stderr, "(%d+%d+%d) = %d (0x%x)\n         ",
		    s->textSize,
		    s->dataSize + s->sdataSize,
		    s->bssSize + s->sbssSize,
		    s->totalSize, s->totalSize);
	    fprintf(stderr,
		    "exceeds given maximum segment size %d (0x%x)\n",
		    s->maxSize, s->maxSize);
	    sizeViolation = 1;
	}

	/*
	 * XXX Remove this part temporarily because this code generates an error 
	 * for those segments whose address is such like [0x0200_0000, 0x0200_xxxx).
	 */
#if 0
	if (KDM_TO_PHYS(s->address + s->totalSize) >= MAX_ADDRESS)
	{
	    fprintf(stderr, "makedisk: segment \"%s\" [0x%08x, 0x%08x) "
		    "exceeds maximum rdram limit 0x%08x (or 0x%08x)\n",
		    s->name,
		    s->address,
		    s->address + s->totalSize,
		    PHYS_TO_K0(MAX_ADDRESS),
		    PHYS_TO_K1(MAX_ADDRESS));
	    sizeViolation = 1;
	}
#endif

	if (! cartBoot)
	{

	    if (s->flags & SEGFLAG_BOOT)
	    {
		if ( ( (KDM_TO_PHYS(s->address) >= IPL4_START) &&
		      (KDM_TO_PHYS(s->address) < IPL4_END) ) ||
		    ( (IPL4_START >= KDM_TO_PHYS(s->address)) &&
		     (IPL4_START < KDM_TO_PHYS(s->address + s->totalSize)) ) )
		{
		    fprintf(stderr, "makedisk: segment \"%s\" [0x%08x, 0x%08x) "
			    "overlaps with IPL [0x%08x, 0x%08x) (or [0x%08x, 0x%08x))\n",
			    s->name,
			    s->address,
			    s->address + s->totalSize,
			    PHYS_TO_K0(IPL4_START),
			    PHYS_TO_K0(IPL4_END),
			    PHYS_TO_K1(IPL4_START),
			    PHYS_TO_K1(IPL4_END));
		    sizeViolation = 1;
		}
	    }

	}

	if ( (s->media == MEDIA_DISK) &&
	    (s->startLba != LBA_NONE) &&
	    (s->startLba + s->sizeInLba - 1 >= NUM_LBAS) )
	{
	    fprintf(stderr, "makedisk: segment \"%s\" exceeds maximum "
		    "lba(%d)\n", s->name, NUM_LBAS);
	    sizeViolation = 1;
	}

	if ( ( s->textSize + s->dataSize + s->sdataSize > 0 )
	    && (s->media == MEDIA_DISK)
	    && (s->startLba != LBA_NONE) )
	    allRom = 0;
    }

    if (sizeViolation)
	return(-1);
    else
	return(0);

}



////////////////////////////////////////////////////////////////////////////////
// checkOverlaps()
//
//
//
int checkOverlaps(void)
{
    Wave *w;
    SegmentChain *sc, *tc;
    Segment *s, *t;
    int isOverlap = 0;
    
    for (w = waveList; w != (Wave *)NULL; w = w->next){
	for (sc = w->segmentChain; sc != NULL; sc = sc->next) {
	    for (tc = sc->next; tc != NULL; tc = tc->next) {
		s = sc->segment;
		t = tc->segment;
		if ((IS_KSEGDM(s->address)) &&
		    (IS_KSEGDM(t->address)) &&
		    ((KDM_TO_PHYS(s->address) + s->totalSize)
		     > KDM_TO_PHYS(t->address)) &&
		    ((KDM_TO_PHYS(t->address) + t->totalSize)
		     > KDM_TO_PHYS(s->address))){
		    fprintf(stderr,
			    "makedisk: segment \"%s\" [0x%x, 0x%x) overlaps with\n",
			    s->name, s->address, s->address + s->totalSize);
		    fprintf(stderr,
			    "         segment \"%s\" [0x%x, 0x%x)\n",
			    t->name, t->address, t->address + t->totalSize);
		    fprintf(stderr, "         in wave \"%s\"\n", w->name);
		    isOverlap =1;
		}

		if ( (s->media == MEDIA_DISK) &&
		    (s->startLba != LBA_NONE) )
		{
		    if ( ((s->startLba >= t->startLba) &&
			  (s->startLba <= t->startLba + t->sizeInLba - 1)) ||
			((t->startLba >= s->startLba) &&
			 (t->startLba <= s->startLba + s->sizeInLba - 1)) )
		    {
			fprintf(stderr,
				"makedisk: segment \"%s\" [LBA%d, %d] overlaps with\n",
				s->name, s->startLba,
				s->startLba + s->sizeInLba - 1);
			fprintf(stderr,
				"          segment \"%s\" [LBA%d, %d]\n",
				t->name, t->startLba,
				t->startLba + t->sizeInLba - 1);

			isOverlap =1;
			
		    }
		}

	    }
	}
    }
    return(isOverlap);
}


////////////////////////////////////////////////////////////////////////////////
// createSegmentSymbols()
//
// The "offset" variable used in here is 0 unless set with -O option.
//
int createSegmentSymbols(char *source, char *object, char *romfile, char *diskfile)
{
    FILE	*f, *fg;
    Segment	*s;
    char	*cmd;
    int   lba = 0;
    int   	bytes;
    int		nblocks = 0, nbytes = 0, nrest = 0;
    
    if ((f = fopen(source, "w")) == NULL) {
	fprintf(stderr, "makedisk: %s: cannot create\n", source);
	return(-1);
    }

    if (! allRom)
    {
	// Disk-specific
	// Open filename to write leo commands to.
	if (generateArgs) {
	    if ((fg = fopen(argFileName, "w+")) == NULL) {
		fprintf(stderr, "makedisk: %s: cannot create\n", argFileName);
		return(-1);
	    }
	} else {
	    if ((fg = fopen(scriptFile, "w+")) == NULL) {
		fprintf(stderr, "makedisk: %s: cannot create\n", scriptFile);
		return(-1);
	    }
	    chmod(scriptFile, 0755);
	}

    }

    /*
     * ディスクイメージマップ出力
     */
    fprintf(stderr, "\n\t\tDISK IMAGE MAP\n\n");
    fprintf(stderr, "    Segment     Size(bytes)\tLba usage      Occupied(bytes)\tRest(bytes)\n");

    for (s = segmentList; s != NULL; s = s->next) {

	/* ロムカートリッジ用シンボル */
	if (s->media == MEDIA_CART)
	{
	    fprintf(f, ".globl _%sSegmentRomStart; ", s->name);
	    fprintf(f, "_%sSegmentRomStart = 0x%08x\n",
		    s->name, s->romOffset + RAMROM_GAME_OFFSET + offset);
	    fprintf(f, ".globl _%sSegmentRomEnd; ", s->name);
	    fprintf(f, "_%sSegmentRomEnd = 0x%08x\n", s->name,
		    s->romOffset + RAMROM_GAME_OFFSET + offset + 
		    s->textSize + s->dataSize + s->sdataSize);
	}
	
	/* ディスク専用シンボル */
	if ( s == segmentList ){
	    char		idString[256];
	    
	    /*
	     * カセット起動の場合、ブートセグメントをディスクに書込むことはない
	     */
	    if (! cartBoot)
	    {
		if(generateArgs)
		    fprintf(fg, "# %s segment\n", s->name);
		else
		    fprintf(fg, "leowrite ");
		
		if (existIDFile)
		    sprintf(idString, "-I %s ", idFileName);
		else
		    idString[0] = '\0';
		
		fprintf(fg, "%s-L %d -w %d-%d -a 0x%08x -t %d %s\n",
			idString,
			s->startLba, 0,
			s->diskOffset + offset + 
			s->textSize + s->dataSize + s->sdataSize -1,
			bootAddress, disktype, diskfile);

		fprintf(f, ".globl _%sSegmentDiskStart; ", s->name);
		fprintf(f, "_%sSegmentDiskStart = %d\n", s->name, s->startLba);
		
		fprintf(f, ".globl _%sSegmentDiskEnd; ", s->name);
		fprintf(f, "_%sSegmentDiskEnd = %d\n", s->name,
			s->startLba + s->sizeInLba);
		
		/*
		 * ディスクイメージマップ出力
		 * (cartBoot が０なので、ブートセグメントはディスクにはいる)
		 */
		bytes = lba2Byte(disktype, s->startLba, s->sizeInLba);
		fprintf(stderr, "    %-12s%8d    %4d(%4d - %4d)\t%8d        %7d\n", s->name,
			s->textSize + s->dataSize + s->sdataSize + 0x50,
			s->sizeInLba,
			s->startLba,
			s->startLba + s->sizeInLba - 1,
			bytes,
			bytes - (s->textSize + s->dataSize + s->sdataSize + 0x50) );

		nbytes += s->textSize + s->dataSize + s->sdataSize + 0x50;
		nblocks += s->sizeInLba;
		nrest += bytes - (s->textSize + s->dataSize + s->sdataSize + 0x50);
	    }

	} else if ( s->textSize + s->dataSize + s->sdataSize > 0 ) {

	    if(s->media == MEDIA_DISK)
	    {
		if (s->startLba != LBA_NONE)
		{
		    if(generateArgs)
			fprintf(fg, "# %s segment\n", s->name);
		    else
			fprintf(fg, "leowrite ");
		    
		    fprintf(fg, "-L %d -w %d-%d -t %d %s\n", s->startLba,
			    s->diskOffset + offset,
			    s->diskOffset + offset + 
			    s->textSize + s->dataSize + s->sdataSize -1,
			    disktype, diskfile);
		    
		    fprintf(f, ".globl _%sSegmentDiskStart; ", s->name);
		    fprintf(f, "_%sSegmentDiskStart = %d\n", s->name, s->startLba);
		    
		    
		    fprintf(f, ".globl _%sSegmentDiskEnd; ", s->name);
		    fprintf(f, "_%sSegmentDiskEnd = %d\n", s->name,
			    s->startLba + s->sizeInLba);

		    /*
		     * ディスクイメージマップ出力
		     */
		    bytes = lba2Byte(disktype, s->startLba, s->sizeInLba);
		    fprintf(stderr, "    %-12s%8d    %4d(%4d - %4d)\t%8d        %7d\n", s->name,
			    s->textSize + s->dataSize + s->sdataSize,
			    s->sizeInLba,
			    s->startLba,
			    s->startLba + s->sizeInLba - 1,
			    bytes,
			    bytes - (s->textSize + s->dataSize + s->sdataSize) );

		    nbytes += s->textSize + s->dataSize + s->sdataSize;
		    nblocks += s->sizeInLba;
		    nrest += bytes - (s->textSize + s->dataSize + s->sdataSize);

		}
		else
		{
		    /*
		     * ディスクイメージマップ出力
		     */
		    fprintf(stderr, "    %-11s(%8d)       none\n", s->name,
			    s->textSize + s->dataSize + s->sdataSize);

		    /*
		     * NONE 指定の場合は、nbytes にバイト数を加算しない。
		     */
		}

	    } /* if (s->media == MEDIA_DISK) */
	    
	}

	if (s->flags & SEGFLAG_OBJECT) {
	    fprintf(f, ".globl _%sSegmentStart; ", s->name);
	    fprintf(f, "_%sSegmentStart = 0x%08x\n",
		    s->name, s->address);
	    
	    /*
	     * text section
	     */
	    fprintf(f, ".globl _%sSegmentTextStart; ", s->name);
	    fprintf(f, "_%sSegmentTextStart = 0x%08x\n",
		    s->name, s->textStart);
	    fprintf(f, ".globl _%sSegmentTextEnd; ", s->name);
	    fprintf(f, "_%sSegmentTextEnd = 0x%08x\n",
		    s->name,
		    s->textStart + s->textSize);

	    /*
	     * data section
	     */
	    fprintf(f, ".globl _%sSegmentDataStart; ", s->name);
	    fprintf(f, "_%sSegmentDataStart = 0x%08x\n",
		    s->name,
		    s->dataStart);
	    fprintf(f, ".globl _%sSegmentDataEnd; ", s->name);
	    fprintf(f, "_%sSegmentDataEnd = 0x%08x\n",
		    s->name,
		    s->dataStart + s->dataSize + s->sdataSize);

	    /*
	     * bss section
	     */
	    fprintf(f, ".globl _%sSegmentBssStart; ", s->name);
	    fprintf(f, "_%sSegmentBssStart = 0x%08x\n",
		    s->name,
		    s->sbssStart);
	    fprintf(f, ".globl _%sSegmentBssEnd; ", s->name);
	    fprintf(f, "_%sSegmentBssEnd = 0x%08x\n",
		    s->name,
		    s->sbssStart + s->sbssSize + s->bssSize);
	    
	    fprintf(f, ".globl _%sSegmentEnd; ", s->name);
	    fprintf(f, "_%sSegmentEnd = 0x%08x\n",
		    s->name,
		    s->bssStart + s->bssSize);
	}

    }

    /*
     * ディスクイメージマップ出力
     */
    fprintf(stderr, "    -----------------------------------------------------------------------\n");
    fprintf(stderr, "    %-12s%8d    %4d blocks\t\t\t\t%7d\n", "total",
	    nbytes, nblocks, nrest);

    fprintf(stderr, "\n\n");

    if (! allRom)
    {
	fclose(fg);
    }
    
    fclose(f);
    
    if ((cmd = (char *)malloc(sysconf(_SC_ARG_MAX))) == NULL) {
	fprintf(stderr, "malloc failed\n");
	return(-1);
    }
    strcpy(cmd, "$TOOLROOT/usr/bin/cc -c -non_shared -o ");
    strcat(cmd, object);
    strcat(cmd, " ");
    strcat(cmd, source);
    
    if (debug)
	printf("  %s\n", cmd);
    
    return(execCommand(cmd));
}


////////////////////////////////////////////////////////////////////////////////
// createRomImage()
//
// object == entry object filename
//
int createRomImage(char *romFile, char *diskFile, char *object) {
    FILE		*fRom, *fDisk;
    Segment	*s;
    ptrdiff_t	bootStack;
    char		*sectName;
    size_t	romSize, diskSize;
    int		fd;
    Elf		*elf;
    Elf32_Ehdr 	*ehdr;
    Elf_Scn	*scn;
    Elf32_Shdr	*shdr;
    int		index;
    int		end;
    int 		i;
    char 		*fillbuffer;
    Wave		*wave;
    
    // Open the entry object
    // Find the TEXT section of the entry object, do some checking
    //   to make sure it is the proper size.
    // Copy the entry object's text section into the beginning of
    //   the rom image.
    //
    if ((fd = open(object, O_RDONLY)) == -1) {
	fprintf(stderr,
		"makedisk: %s: %s\n",
		object, sys_errlist[errno]);
	return(-1);
    }
    elf = elf_begin(fd, ELF_C_READ, (Elf *)NULL);
    ehdr = elf32_getehdr(elf);
    for (index = 1; index < ehdr->e_shnum; index++) {
	scn = elf_getscn(elf, index);
	shdr = elf32_getshdr(scn);
	sectName = elf_strptr(elf,ehdr->e_shstrndx,(size_t)shdr->sh_name);
	if (strcmp(sectName, ELF_TEXT) == 0)
	    break;
    }
    if (shdr->sh_size > SizeofEntryRoutine) {
	fprintf(stderr, "makedisk: entr size %d is larger than %d\n", 
		shdr->sh_size, SizeofEntryRoutine);
	return(-1);
    }
    if (lseek(fd, shdr->sh_offset, SEEK_SET) == -1) {
	fprintf(stderr, "makedisk: lseek of entry section failed\n");
	return(-1);
    }

    /*
     * Entry Object はロム起動のときはロム側へ、ディスク起動のときは
     * ディスク側にいれる。
     */
    if (cartBoot)
    {
	if (read(fd, romImage, shdr->sh_size) != shdr->sh_size) {
	    fprintf(stderr, "makedisk: read of entry section failed\n");
	    return(-1);
	}
    } 
    else 
    {
	if (read(fd, diskImage, shdr->sh_size) != shdr->sh_size) {
	    fprintf(stderr, "makedisk: read of entry section failed\n");
	    return(-1);
	}
    }  
    
    // Open all of the a.outs, giving them both a
    // file descriptor and an Elf descriptor.
    //
    if (openAouts())
	return(-1);
    
    // Read all the a.outs
    for (s = segmentList; s != NULL; s = s->next) {

	/*
	 * readXX 側で、ロム側かディスク側か振り分けてくれる。
	 */ 
	if (s->flags & SEGFLAG_OBJECT)
	    readObject(s);
	else if (s->flags & SEGFLAG_RAW)
	    readRaw(s);
	
	/*
	 * サイズの計算
	 */
	if (s->media == MEDIA_CART)
	{
	    romSize = s->romOffset +
		s->textSize + s->dataSize + s->sdataSize;
	}
	else
	{
	    diskSize = s->diskOffset +
		s->textSize + s->dataSize + s->sdataSize;
	}
	
    }
    
    /*
     * 起動ゲームの場合、LeoBootGame 関数を探し出して
     * 暗号化する
     */
    if (booter)
    {
	for (wave = waveList; wave != (Wave *)NULL; wave = wave->next)
	    if (cryptRomBoot(wave))
	    {
		return(-1);
	    }
    }
    
    //
    // Should close up all of the file and Elf descriptors,
    // but we're almost ready to exit, so skip it.
    //
    
    /*
     * もしロム起動なら、ロムイメージを作成する。
     */

    if (cartBoot)
    {
	// Open rom file
	if ((fRom = fopen(romFile, "w+")) == NULL) {
	    fprintf(stderr, "makedisk: %s: %s\n",
		    romFile, sys_errlist[errno]);
	    return(-1);
	}

	// If offset set, seek to a position after the offset.
	// If not set, offset value is 0.
	if (offset != 0)
	    if (fseek(fRom, offset, SEEK_SET) != 0) {
		fprintf(stderr, "makedisk: %s: fseek error (%s)\n",
			romFile, sys_errlist[errno]);
		return(-1);
	    } 

	// Write out the headerBuf
	if (fwrite(headerBuf, sizeof(char), headerWordAlignedByteSize, fRom) != headerWordAlignedByteSize) {
	    fprintf(stderr, "makedisk: %s: write error\n", romFile);
	    return(-1);
	}

	// Seek to byte 8
	if (fseek(fRom, RAMROM_BOOTADDR_OFFSET + offset, SEEK_SET) != 0) {
	    fprintf(stderr, "makedisk: %s: fseek error (%s)\n",
		    romFile, sys_errlist[errno]);
	    return(-1);
	}
	// Write the boot address (4 bytes) to the rom file
	if (fwrite(&bootAddress, sizeof(int), 1, fRom) != 1) {
	    fprintf(stderr, "makedisk: %s: write error\n", romFile);
	    return(-1);
	}

	// Seek to byte x40 (x400 for HW1)
	if (fseek(fRom, RAMROM_BOOTSTRAP_OFFSET + offset, SEEK_SET) != 0) {
	    fprintf(stderr, "makedisk: %s: fseek error (%s)\n",
		    romFile, sys_errlist[errno]);
	    return(-1);
	}
	// Write bootbuf to rom file
	if (fwrite(bootBuf, sizeof(char), bootWordAlignedByteSize, fRom) != bootWordAlignedByteSize) {
	    fprintf(stderr, "makedisk: %s: write error\n", romFile);
	    return(-1);
	}

	// Seek and write pif2boot to rom file if HW1
#ifdef _HW_VERSION_1
	if (fseek(fRom, RAMROM_PIF2BOOTSTRAP_OFFSET + offset, SEEK_SET) != 0) {
	    fprintf(stderr, "makedisk: %s: fseek error (%s)\n",
		    romFile, sys_errlist[errno]);
	    return(-1);
	}
	if (fwrite(pif2bootBuf, sizeof(char), pif2bootWordAlignedByteSize, fRom) != pif2bootWordAlignedByteSize) {
	    fprintf(stderr, "makedisk: %s: write error\n", romFile);
	    return(-1);
	}
#else

	if (nofont == 0) {
	    // Seek to byte xb70
	    if (fseek(fRom, RAMROM_FONTDATA_OFFSET + offset, SEEK_SET) != 0) {
		fprintf(stderr, "makedisk: %s: fseek error (%s)\n",
			romFile, sys_errlist[errno]);
		return(-1);
	    }
	    // Write fontBuf to rom file
	    if (fwrite(fontBuf, sizeof(char), fontdataWordAlignedByteSize, fRom) != fontdataWordAlignedByteSize) {
		fprintf(stderr, "makedisk: %s: write error\n", romFile);
		return(-1);
	    }
	}
#endif /* _HW_VERSION_1 */

	// Seek to byte x1000 (x2000 for HW1)
	if (fseek(fRom, RAMROM_GAME_OFFSET + offset, SEEK_SET) != 0) {
	    fprintf(stderr, "makedisk: %s: fseek error (%s)\n",
		    romFile, sys_errlist[errno]);
	    return(-1);
	}
	// Write romImage to rom file
	if (fwrite(romImage, sizeof(char), romSize, fRom) != romSize) {
	    fprintf(stderr, "makedisk: %s: write error\n", romFile);
	    return(-1);
	}
	
	// Fill rom file with fill bytes if requested
	end = romSize + RAMROM_GAME_OFFSET + offset;
	finalromSize *= (0x100000/8);
	if ((finalromSize != 0) && ( finalromSize > end)) {
	    if ((fillbuffer = (char *)malloc(FILLBUFFER)) == NULL) {
		fprintf(stderr, "malloc failed\n");
		return(-1);
	    }
	    for (i = 0; i < FILLBUFFER; i++)
		*(fillbuffer + i) = fillData;
	    while (end < finalromSize) {
		if ((finalromSize - end) > FILLBUFFER){
		    if (fwrite(fillbuffer, sizeof(char), 
			       FILLBUFFER, fRom) != FILLBUFFER){
			fprintf(stderr, "makedisk: %s: write error %x\n",
				romFile, end);
			return(-1);
		    }
		    end += FILLBUFFER;
		} else {
		    if (fwrite(fillbuffer, sizeof(char), 
			       (finalromSize - end), fRom) != (finalromSize - end)){
			fprintf(stderr, "makedisk: %s: write error\n",
				romFile);
			return(-1);
		    }
		    end += (finalromSize - end);
		}
		
	    }
	}
	
	fclose(fRom);

    } /* if (cartBoot) */


    if(! allRom )		/* 全てのセグメントがロム側でなければ、必ずディスク側があるはず */
    {
	/*
	 * ディスクイメージをファイルに出力
	 */
	// Open disk file
	if ((fDisk = fopen(diskFile, "w+")) == NULL) {
	    fprintf(stderr, "makedisk: %s: %s\n",
		    diskFile, sys_errlist[errno]);
	    return(-1);
	}
	
	// If offset set, seek to a position after the offset.
	// If not set, offset value is 0.
	if (offset != 0)
	    if (fseek(fDisk, offset, SEEK_SET) != 0) {
		fprintf(stderr, "makedisk: %s: fseek error (%s)\n",
			diskFile, sys_errlist[errno]);
		return(-1);
	    } 
	
	/*
	 * 被起動ゲームなら、disk image の 0 から２５６バイトを暗号化する
	 */
	if (bootee)
	{
	    int		cryptSize = 256;
	    char	cryptBuf[256];
	    int		cryptSeed = 17;		/* cryptSize と互いに素であること */
	    int		i, k;

	    for(i = 0; i < cryptSize; i++)
	    {
		k = i;
		while(k % cryptSeed != 0)
		    k += cryptSize;
		
		cryptBuf[k/cryptSeed] = diskImage[i];
	    }

	    bcopy((void *)cryptBuf, (void *)diskImage, cryptSize);

	}
	
	// Write diskImage to disk file
	if (fwrite(diskImage, sizeof(char), diskSize, fDisk) != diskSize) {
	    fprintf(stderr, "makedisk: %s: write error\n", diskFile);
	    return(-1);
	}
	
	fclose(fDisk);

    } /* if (! allRom) */
    
    return(0);
}


////////////////////////////////////////////////////////////////////////////////
// openAouts()
//
// For each wave, open the generated a.out file and use it to create the
//   Rom later on.
//
static int openAouts(void) {
    Wave *wave;
    char gcordFileBuf[256];
    
    // For each wave in the spec file.
    //
    for (wave = waveList; wave != (Wave *)NULL; wave = wave->next) {
	if ( gcord )
	    strcat( strcpy( gcordFileBuf, wave->name ), ".cord" );
	else
	    strcpy( gcordFileBuf, wave->name );
	
	if ((wave->fd = open(wave->name, O_RDONLY)) == -1) {
	    fprintf(stderr,
		    "makedisk: %s: %s\n",
		    wave->name, sys_errlist[errno]);
	    return(-1);
	}
	wave->elf = elf_begin(wave->fd, ELF_C_READ, (Elf *)NULL);
	if ((elf_kind(wave->elf) != ELF_K_ELF) ||
	    ((wave->ehdr = elf32_getehdr(wave->elf)) == NULL)) {
	    fprintf(stderr,
		    "makedisk: %s: not a valid ELF object file\n",
		    wave->name);
	    return(-1);
	}
    }
    return(0);
}


////////////////////////////////////////////////////////////////////////////////
// lookupSymbol()
//
//
//
static void *lookupSymbol(Wave *wave, char *name) {
    Elf_Scn *scn;
    Elf32_Shdr *shdr;
    Elf_Data *data;
    Elf32_Sym *sym;
    size_t index;
    int i, count;
    
    for (index = 1; index < wave->ehdr->e_shnum; index++) {
	if (((scn = elf_getscn(wave->elf, index)) == NULL) ||
	    ((shdr = elf32_getshdr(scn)) == NULL)) {
	    return(NULL);
	}
	if (shdr->sh_type != SHT_SYMTAB)
	    continue;
	data = (Elf_Data *)NULL;
	if ((data = elf_getdata(scn, data)) == NULL)
	    return(NULL);
	count = data->d_size/sizeof(Elf32_Sym);
	sym = (Elf32_Sym *)data->d_buf;
	sym++;		/* first symbol is for undefined */
	for (i = 1; i < count; i++) {
	    if (strcmp(name,
		       elf_strptr(wave->elf, shdr->sh_link, sym->st_name))
		== 0)
		return((void *)sym->st_value);
	    sym++;
	}
    }
    return(NULL);
}


////////////////////////////////////////////////////////////////////////////////
// lookupShdr()
//
//
//
static Elf32_Shdr *lookupShdr(Wave *wave, char *segSectName) {
    Elf_Scn *scn;
    Elf32_Shdr *shdr;
    size_t index;
    char *sectName;
    
    for (index = wave->searchIndex; index < wave->ehdr->e_shnum; index++) {
	if (((scn = elf_getscn(wave->elf, index)) == NULL) ||
	    ((shdr = elf32_getshdr(scn)) == NULL)) {
	    fprintf(stderr,
		    "makedisk: %s: can't get section index %d\n",
		    wave->name, index);
	    return(NULL);
	}
	sectName = elf_strptr(wave->elf, wave->ehdr->e_shstrndx,
			      (size_t)shdr->sh_name);
	if (strcmp(sectName, segSectName) == 0)
	    break;
    }
    if (index < wave->ehdr->e_shnum) {
	wave->searchIndex = index + 1;
	return(shdr);
    }

    for (index = 1; index < wave->searchIndex; index++) {
	if (((scn = elf_getscn(wave->elf, index)) == NULL) ||
	    ((shdr = elf32_getshdr(scn)) == NULL)) {
	    fprintf(stderr,
		    "makedisk: %s: can't get section index %d\n",
		    wave->name, index);
	    return(NULL);
	}
	sectName = elf_strptr(wave->elf, wave->ehdr->e_shstrndx,
			      (size_t)shdr->sh_name);
	if (strcmp(sectName, segSectName) == 0)
	    break;
    }
    if (index >= wave->searchIndex) {
	fprintf(stderr, "makedisk: %s: cannot find %s section\n",
		wave->name, segSectName);
	return(NULL);
    }

    wave->searchIndex = index + 1;
    return(shdr);

}


////////////////////////////////////////////////////////////////////////////////
// readObject()
//
// Reads the good stuff out of an a.out and stores it in the proper
//   position in the romImage memory buffer.
//
static int readObject(Segment *s) {
    char		*segSectName;
    Elf32_Shdr	*shdr;
    
    if ((segSectName = (char *)malloc(strlen(s->name)+9)) == NULL) {
	fprintf(stderr, "malloc failed\n");
	return(-1);
    }
    
    // read in the text
    //
    sprintf(segSectName, ".%s.text", s->name);
    if ((shdr = lookupShdr(s->wave, segSectName)) == NULL)
	return(-1);
    
    if (shdr->sh_size != s->textSize) {
	fprintf(stderr,
		"makedisk: %s: section size for %s does not match input section sizes\n",
		s->wave->name, segSectName);
	fprintf(stderr, 
		"makedisk:   shdr = %d, textSize = %d\n", shdr->sh_size, s->textSize);
	free(segSectName);
	return(-1);
    }
    
    if (lseek(s->wave->fd, shdr->sh_offset, SEEK_SET) == -1) {
	fprintf(stderr, "makedisk: %s: seek to section %s failed\n",
		s->wave->name, segSectName);
	free(segSectName);
	return(-1);
    }

    if (s->media == MEDIA_CART)
    {
	if (read(s->wave->fd, romImage + s->romOffset,
		 shdr->sh_size) != shdr->sh_size) {
	    fprintf(stderr, "makedisk: %s: read of section %s failed\n",
		    s->wave->name, segSectName);
	    free(segSectName);
	    return(-1);
	}
    }
    else
    {
	if (read(s->wave->fd, diskImage + s->diskOffset,
		 shdr->sh_size) != shdr->sh_size) {
	    fprintf(stderr, "makedisk: %s: read of section %s failed\n",
		    s->wave->name, segSectName);
	    free(segSectName);
	    return(-1);
	}
    }
    
    // read in the (large) data
    //
    sprintf(segSectName, ".%s.data", s->name);
    if ((shdr = lookupShdr(s->wave, segSectName)) == NULL)
	return(-1);
    if (shdr->sh_size != s->dataSize) {
	fprintf(stderr,
		"makedisk: %s: section size for %s does not match input section sizes\n",
		s->wave->name, segSectName);
	fprintf(stderr, "large data failed\n");
	fprintf(stderr, "%s, file large=%x, our dataSize=%x\n",s->name,
		shdr->sh_size, s->dataSize);
	free(segSectName);
	return(-1);
    }
    if (lseek(s->wave->fd, shdr->sh_offset, SEEK_SET) == -1) {
	fprintf(stderr, "makedisk: %s: seek to section %s failed\n",
		s->wave->name, segSectName);
	free(segSectName);
	return(-1);
    }
    if (s->media == MEDIA_CART)
    {
	if (read(s->wave->fd, romImage + s->romOffset + s->textSize,
		 shdr->sh_size) != shdr->sh_size) {
	    fprintf(stderr, "makedisk: %s: read of section %s failed\n",
		    s->wave->name, segSectName);
	    free(segSectName);
	    return(-1);
	}
    }
    else
    {
	if (read(s->wave->fd, diskImage + s->diskOffset + s->textSize,
		 shdr->sh_size) != shdr->sh_size) {
	    fprintf(stderr, "makedisk: %s: read of section %s failed\n",
		    s->wave->name, segSectName);
	    free(segSectName);
	    return(-1);
	}
    }
    
    // read in the small data
    //
    sprintf(segSectName, ".%s.sdata", s->name);
    if ((shdr = lookupShdr(s->wave, segSectName)) == NULL)
	return(-1);
    if (shdr->sh_size != s->sdataSize) {
	fprintf(stderr,
		"makedisk: %s: section size for %s does not match input section sizes\n",
		s->wave->name, segSectName);
	fprintf(stderr, "small data failed\n");
	free(segSectName);
	return(-1);
    }
    if (lseek(s->wave->fd, shdr->sh_offset, SEEK_SET) == -1) {
	fprintf(stderr, "makedisk: %s: seek to section %s failed\n",
		s->wave->name, segSectName);
	free(segSectName);
	return(-1);
    }
    if (s->media == MEDIA_CART)
    {
	if (read(s->wave->fd,
		 romImage + s->romOffset + s->textSize + s->dataSize,
		 shdr->sh_size) != shdr->sh_size) {
	    fprintf(stderr, "makedisk: %s: read of section %s failed\n",
		    s->wave->name, segSectName);
	    free(segSectName);
	    return(-1);
	}
    }
    else
    {
	if (read(s->wave->fd,
		 diskImage + s->diskOffset + s->textSize + s->dataSize,
		 shdr->sh_size) != shdr->sh_size) {
	    fprintf(stderr, "makedisk: %s: read of section %s failed\n",
		    s->wave->name, segSectName);
	    free(segSectName);
	    return(-1);
	}
    }
    
    free(segSectName);
    return(0);
}


/***********************************************************************
 * readRaw()
 * 
 *
 ***********************************************************************/
static int readRaw(Segment *s) {
    Path *p;
    int fd;
    unsigned int offset;
    off_t fileSize, totalSize = 0;
    struct stat statBuffer;
    
    if (s->media == MEDIA_CART)
    {
	offset = s->romOffset;
	
	for (p = s->pathList; p != NULL; p = p->next) {
	    if ((fd = open(p->name, O_RDONLY)) == -1) {
		fprintf(stderr, "makedisk: %s: %s\n",
			p->name, sys_errlist[errno]);
		return(-1);
	    }
	    if (fstat(fd, &statBuffer) == -1) {
		fprintf(stderr, "makedisk: lstat failed: %s\n",
			sys_errlist[errno]);
		return(-1);
	    }
	    fileSize = statBuffer.st_size;
	    totalSize += fileSize;
	    if (totalSize > s->dataSize) {
		fprintf(stderr, "makedisk: %s: segment size changed\n",
			s->name);
		return(-1);
	    }
	    if (read(fd, romImage + offset, fileSize) != fileSize) {
		fprintf(stderr, "makedisk: %s: read failed (%s)\n",
			p->name, sys_errlist[errno]);
		return(-1);
	    }
	    close(fd);
	    offset += fileSize;
	}
    }
    else /* media != cart */
    {
	offset = s->diskOffset;
	
	for (p = s->pathList; p != NULL; p = p->next) {
	    if ((fd = open(p->name, O_RDONLY)) == -1) {
		fprintf(stderr, "makedisk: %s: %s\n",
			p->name, sys_errlist[errno]);
		return(-1);
	    }
	    if (fstat(fd, &statBuffer) == -1) {
		fprintf(stderr, "makedisk: lstat failed: %s\n",
			sys_errlist[errno]);
		return(-1);
	    }
	    fileSize = statBuffer.st_size;
	    totalSize += fileSize;
	    if (totalSize > s->dataSize) {
		fprintf(stderr, "makedisk: %s: segment size changed\n",
			s->name);
		return(-1);
	    }
	    if (read(fd, diskImage + offset, fileSize) != fileSize) {
		fprintf(stderr, "makedisk: %s: read failed (%s)\n",
			p->name, sys_errlist[errno]);
		return(-1);
	    }
	    close(fd);
	    offset += fileSize;
	}

    } /* if media != cart */

    return(0);
}


////////////////////////////////////////////////////////////////////////////////
// createEntryFile()
//
// This is called after the linking stage and fmulmul has been checked.
// Therefore the entry point symbol address is created by looking at the
//   linked ELF file.
//
int createEntryFile(char *source, char *object) {
    Segment 	*s;
    FILE		*f;
    char		*cmd;
    char		*segSectName;
    void 		*BssStart;
    struct Wave_s	*wave;
    void 		*bootEntry = NULL, *bootStack = NULL;
    char		romsymbol[14] = "__osFinalrom";
    
    // Open up file to put source into.
    if ((f = fopen(source, "w")) == NULL) {
	fprintf(stderr, "makedisk: %s: cannot create\n", source);
	return(-1);
    }
    
    // Look for the boot segment
    for (s = segmentList; s != NULL; s = s->next) {
	if (s->flags & SEGFLAG_BOOT) {
	    wave = s->wave;
	    if ((wave->fd = open(wave->name, O_RDONLY)) == -1) {
		fprintf(stderr,
			"makedisk: %s: %s\n",
			wave->name, sys_errlist[errno]);
		return(-1);
	    }
	    wave->elf = elf_begin(wave->fd, ELF_C_READ, (Elf *)NULL);
	    if ((elf_kind(wave->elf) != ELF_K_ELF) ||
		((wave->ehdr = elf32_getehdr(wave->elf)) == NULL)) {
		fprintf(stderr,
			"makedisk: %s: not a valid ELF object file\n",
			wave->name);
		return(-1);
	    }
	    if (finalromSize != 0) {
		if (lookupSymbol(s->wave,romsymbol) == NULL){
		    fprintf(stderr,
			    "makedisk: use libultra_rom.a to build real game cassette\n");
		    return(-1);
		}
	    }

	    // Find the boot entry point address
	    if (bootEntryName != NULL) {
		bootEntry = lookupSymbol(s->wave, 
					 bootEntryName); 
		if (bootEntry == NULL) {
		    fprintf(stderr,
			    "makedisk: %s: cannot find entry symbol %s\n",
			    s->wave->name, bootEntryName);
		    return(-1);
		}
	    }

	    // Find the boot stack address
	    if (bootStackName != (char *)NULL) {
		if ((bootStack =
		     lookupSymbol(s->wave, bootStackName)) == NULL) {
		    fprintf(stderr,
			    "makedisk: %s: cannot find stack symbol %s\n",
			    s->wave->name, bootStackName);
		    return(-1);
		}
	    } else {
		bootStack = 0;
	    }
	    bootStack = (void *) ((ptrdiff_t)bootStack +
				  bootStackOffset);
	    
	    // find Bss address
	    /*
	     * 下記のルーチンは絶対に変更しないでください
	     * (if (bootEntry) の終りまで)
	     * DD のプログラムで、ドライブが挿さっているかの
	     * 判断に使用されます。
	     */
	    if (s->bssSize > 0 && (cosim == 0)) {
		if ((segSectName = (char *)malloc(strlen(s->name)+16)) == NULL) {
		    fprintf(stderr, "malloc failed\n");
		    return(-1);
		}
		sprintf(segSectName, "_%sSegmentBssStart", 
			s->name);
		BssStart = lookupSymbol(s->wave, segSectName);
		fprintf(f, " la	$8 0x%x\n", BssStart);
		fprintf(f, " li	$9 0x%x\n", s->bssSize);
		fprintf(f, "1:\n");
		fprintf(f, " sw $0, 0($8)\n");
		fprintf(f, " sw $0, 4($8)\n");
		fprintf(f, " addi $8, 8\n");
		fprintf(f, " addi $9, 0xfff8\n");
		fprintf(f, " bne  $9, $0, 1b\n");
	    }
	    if (bootStack)
		fprintf(f, " la	$29 0x%x\n", bootStack);
	    if (bootEntry) {
		fprintf(f, " la $10  0x%x\n", bootEntry);
		fprintf(f, " j $10\n");
	    }
	}
    }
    free(segSectName);
    fclose(f);
    
    // Compile the entry point source code
    if ((cmd = (char *)malloc(sysconf(_SC_ARG_MAX))) == NULL) {
	fprintf(stderr, "malloc failed\n");
	return(-1);
    }
    strcpy(cmd, "$TOOLROOT/usr/bin/cc -c -non_shared -o ");
    strcat(cmd, object);
    strcat(cmd, " ");
    strcat(cmd, source);
    
    if (debug) {
	printf("Compiling entry source file\n");
	printf("  %s\n", cmd);
    }

    return(execCommand(cmd));
}


////////////////////////////////////////////////////////////////////////////////
// ALIGNn()
//
// Given a number of bytes n and an alignment value romalign, return the number
//   of bytes which indicates the romalign-aligned size of the n-byte buffer.
//
unsigned int ALIGNn(unsigned int romalign, int n) {
    if(romalign == 0) 
	romalign = 16;
    return (((n + (romalign-1))/romalign)*romalign);
}

/*
 * 同じ定義が bootdisk.c にもあるので、必ず同じ値にしておくこと
 */
#define BOOT1_SIZE	0x344  		/* __LeoBootGame2 のサイズ */
#define BOOT2_SIZE	0x50		/* __LeoBootGame3 のサイズ */

int cryptRomBoot(Wave *wave)
{
    Segment	*s;
    char	string[255];
    void 	*addr, *currSegmentStartAddr, *currSegmentEndAddr;
    void	*segmentRomStart;
    char	*romAddr, *seedAddr;
    char 	*tmpdir;
    int		result, i;
    char	seed;
    static int	isCrypted = 0;

    /*
     * すでに一度暗号化していれば、リターンする
     */
    if(isCrypted)
	return 0;
    
    isCrypted = 1;
    
    // Choose the temporary directory.
    // "/tmp", or TMPDIR if set.
    //
    if ((tmpdir = getenv("TMPDIR")) ==  NULL)
	tmpdir = "/tmp";
    
    /*
     * 後にシンボルの値を入手するため、nm の出力をファイルに落としておく
     */
    sprintf(string, "gnm -Bvx %s > %s/grepResultXXXXX", wave->name, tmpdir);
    result = execCommand(string);
    if(result)
    {
	fprintf(stderr, "error occurred\n");
	return(-1);
    }
    
    /*
     * __LeoBootGame2 がどこにあるかを入手
     */
    result = getSymbolValue("__LeoBootGame2", (u32 *)&addr);
    if(result == 1)
    {
	/* __LeoBootGame2 がないので、そのままリターン */
	return 0;
    }
    else if (result == -1)
    {
	return (-1);
    }
    
    /*
     * __LeoBootGame2 のアドレスを暗号鍵にする。
     */
    seed = ( ( ( (long)addr & 0xff000000 ) >> 24 ) + 
	    ( ( (long)addr & 0x00ff0000 ) >> 16 ) + 
	    ( ( (long)addr & 0x0000ff00 ) >> 8 ) + 
	    ( ( (long)addr & 0x000000ff ) ) ) & 0xff;
    
    /*
     * __LeoBootGame2 はどのセグメントにあるかを調べる
     */
    for (s = segmentList; s != NULL; s = s->next)
    {
	sprintf(string, "_%sSegmentStart", s->name);
	result = getSymbolValue(string, (u32 *)&currSegmentStartAddr);
	if(result)
	{
	    fprintf(stderr, "makedisk: get symbol failed\n");
	    return (-1);
	}

	sprintf(string, "_%sSegmentEnd", s->name);
	result = getSymbolValue(string, (u32 *)&currSegmentEndAddr);
	if(result)
	{
	    fprintf(stderr, "makedisk: get symbol failed\n");
	    return (-1);
	}

	if ( ((u32)currSegmentStartAddr <= (u32)addr) &&
	    ((u32)addr <= (u32)currSegmentEndAddr) )
	{
	    break;
	}
	
    }

    if (s->media == MEDIA_CART)
    {
	romAddr = romImage + s->romOffset +
	    ((u32)addr - (u32)currSegmentStartAddr);
    }
    else
    {
	romAddr = diskImage + s->diskOffset + 
	    ((u32)addr - (u32)currSegmentStartAddr);
    }

    /*
     * 実際にエンクリプトをする
     */
    for(i = 0; i < BOOT1_SIZE; i += 4)
    {
	romAddr[2] += seed;
	romAddr[3] -= seed;
	romAddr += 4;
    }
    
    /*
     * __LeoBootGame3 がどこにあるかを入手
     */
    result = getSymbolValue("__LeoBootGame3", (u32 *)&addr);
    if(result)
    {
	fprintf(stderr, "makedisk: get symbol failed\n");
	return (-1);
    }
    
    if (s->media == MEDIA_CART)
    {
	romAddr = romImage + s->romOffset +
	    ((u32)addr - (u32)currSegmentStartAddr);
    }
    else
    {
	romAddr = diskImage + s->diskOffset + 
	    ((u32)addr - (u32)currSegmentStartAddr);
    }
    
    /*
     * 実際にエンクリプトをする
     */
    for(i = 0; i < BOOT2_SIZE; i += 4)
    {
	romAddr[2] += seed;
	romAddr[3] -= seed;
	romAddr += 4;
    }

    sprintf(string, "%s/grepResultXXXXX", tmpdir);
    unlink(string);

    return 0;
    

} /* cryptRomBoot() */


static int getSymbolValue(char *name, unsigned long *val)
{
    char	string[255];
    char	fileName[255];
    int		result;
    FILE	*f;
    char	value[11];
    void 	*addr;
    char 	*tmpdir;
    int		status;
    
    // Choose the temporary directory.
    // "/tmp", or TMPDIR if set.
    //
    if ((tmpdir = getenv("TMPDIR")) ==  NULL)
	tmpdir = "/tmp";
    
    sprintf(string, "grep %s %s/grepResultXXXXX > %s/grep1LineXXXXX",
	    name, tmpdir, tmpdir);
    status = system(string);
    
    if (status == -1) {
	fprintf(stderr, "makedisk: cannot execute grep\n");
	return(-1);
    } else if ( !(WIFEXITED(status) && (WEXITSTATUS(status) == 0)) ) {
	return(1);	/* grep failed */
    }
    
    sprintf(fileName, "%s/grep1LineXXXXX", tmpdir);
    if ((f = fopen(fileName, "r")) == NULL) {
	fprintf(stderr, "makedisk: grep file: cannot open\n");
	unlink(fileName);
	return(-1);
    }
    
    if (fread(value, sizeof(char), 8, f) != 8) {
	fprintf(stderr,"makedisk: grep file: read error \n");
	fclose(f);
	unlink(fileName);
	return(-1);
    }
    
    value[8] = 0;
    
    fclose(f);
    
    *val = (unsigned long)strtoul(value, (char **)NULL, 16);

    unlink(fileName);
    
    return 0;
    
}