SZS v2.18a

1 files changed, 1208 insertions, 0 deletions

diff --git a/project/dclib/lib-dol.c b/project/dclib/lib-dol.c
new file mode 100644
index 0000000..00d6972
--- /dev/null
+++ b/project/dclib/lib-dol.c
@@ -0,0 +1,1208 @@
+
+/***************************************************************************
+ *                                                                         *
+ *                     _____     ____                                      *
+ *                    |  __ \   / __ \   _     _ _____                     *
+ *                    | |  \ \ / /  \_\ | |   | |  _  \                    *
+ *                    | |   \ \| |      | |   | | |_| |                    *
+ *                    | |   | || |      | |   | |  ___/                    *
+ *                    | |   / /| |   __ | |   | |  _  \                    *
+ *                    | |__/ / \ \__/ / | |___| | |_| |                    *
+ *                    |_____/   \____/  |_____|_|_____/                    *
+ *                                                                         *
+ *                       Wiimms source code library                        *
+ *                                                                         *
+ ***************************************************************************
+ *                                                                         *
+ *        Copyright (c) 2012-2020 by Dirk Clemens <wiimm@wiimm.de>         *
+ *                                                                         *
+ ***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   See file gpl-2.0.txt or http://www.gnu.org/licenses/gpl-2.0.txt       *
+ *                                                                         *
+ ***************************************************************************/
+
+#define _GNU_SOURCE 1
+#include "lib-dol.h"
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    dol header			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void ntoh_dol_header ( dol_header_t * dest, const dol_header_t * src )
+{
+    DASSERT(dest);
+
+    if (!src)
+	src = dest;
+    else if ( dest != src )
+	memcpy(dest,src,sizeof(*dest));
+
+    const u32 * src_ptr = src->sect_off;
+    u32 * dest_ptr = dest->sect_off;
+    u32 * dest_end = (u32*)&dest->padding;
+
+    while ( dest_ptr < dest_end )
+	*dest_ptr++ = ntohl(*src_ptr++);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void hton_dol_header ( dol_header_t * dest, const dol_header_t * src )
+{
+    DASSERT(dest);
+
+    if (!src)
+	src = dest;
+    else if ( dest != src )
+	memcpy(dest,src,sizeof(*dest));
+
+    const u32 * src_ptr = src->sect_off;
+    u32 * dest_ptr = dest->sect_off;
+    u32 * dest_end = (u32*)&dest->padding;
+
+    while ( dest_ptr < dest_end )
+	*dest_ptr++ = htonl(*src_ptr++);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool IsDolHeader ( const void *data, uint data_size, uint file_size )
+{
+    if ( data_size < DOL_HEADER_SIZE )
+	return false;
+
+    const dol_header_t *dol = data;
+    u64 total_size = 0;
+
+    uint i;
+    for ( i = 0; i < DOL_N_SECTIONS; i++ )
+    {
+	const u32 off  = ntohl(dol->sect_off[i]);
+	const u32 size = ntohl(dol->sect_size[i]);
+	const u32 addr = ntohl(dol->sect_addr[i]);
+	noPRINT("DOL: %8x %8x %08x\n",off,size,addr);
+	if ( off || size || addr )
+	{
+	    if (   off & 3
+		|| size & 3
+		|| addr & 3
+		|| off < DOL_HEADER_SIZE
+		|| file_size && off + size > file_size )
+	    {
+		return false;
+	    }
+	    total_size += size;
+	}
+    }
+
+    return total_size && total_size < 0x7fffffff;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+const char dol_section_name[DOL_NN_SECTIONS+1][4] =
+{
+    "T0",
+    "T1",
+    "T2",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+
+    "D0",
+    "D1",
+    "D2",
+    "D3",
+    "D4",
+    "D5",
+    "D6",
+    "D7",
+    "D8",
+    "D9",
+    "D10",
+
+    "BSS",
+    "ENT",
+
+    ""
+};
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			advanced interface		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool GetDolSectionInfo
+(
+    dol_sect_info_t	* info,		// valid pointer: returned data
+    const dol_header_t	*dol_head,	// valid DOL header
+    uint		file_size,	// (file) size of 'data'
+    uint		section		// 0 .. DOL_NN_SECTIONS
+					//	(7*TEXT, 11*DATA, BSS, ENTRY )
+)
+{
+    DASSERT(dol_head);
+    DASSERT(info);
+    memset(info,0,sizeof(*info));
+
+    if ( !dol_head || file_size < sizeof(dol_header_t) || section >= DOL_NN_SECTIONS )
+    {
+	info->section = -1;
+	return false;
+    }
+
+    info->section = section;
+    StringCopyS(info->name,sizeof(info->name),GetDolSectionName(section));
+
+    if ( section < DOL_N_SECTIONS )
+    {
+	const u32 size = be32(&dol_head->sect_size[section]);
+	if (size)
+	{
+	    info->sect_valid = true;
+	    info->size = size;
+	    const u32 off  = info->off = be32(&dol_head->sect_off [section]);
+	    info->addr = be32(&dol_head->sect_addr[section]);
+
+	    if ( off < file_size && size < file_size && off+size <= file_size )
+	    {
+		info->data_valid = true;
+		info->data =  (u8*)dol_head + off;
+	    }
+	}
+	return true;
+    }
+
+    if ( section == DOL_IDX_BSS )
+    {
+	info->sect_valid = true;
+	info->addr = be32(&dol_head->bss_addr);
+	info->size = be32(&dol_head->bss_size);
+	return true;
+    }
+
+    if ( section == DOL_IDX_ENTRY )
+    {
+	info->sect_valid = true;
+	info->addr = be32(&dol_head->entry_addr);
+	return true;
+    }
+
+    ASSERT(0);
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool FindFirstFreeDolSection
+(
+    // returns TRUE on found
+
+    dol_sect_info_t	*info,	// result
+    const dol_header_t	*dh,	// DOL header to analyse
+    uint		mode	// 0: search all sections (TEXT first)
+				// 1: search only TEXT sections
+				// 2: search only DATA sections
+				// 3: search all sections (DATA first)
+)
+{
+    DASSERT(info);
+    DASSERT(dh);
+
+    memset(info,0,sizeof(*info));
+
+    uint idx, end;
+    switch (mode)
+    {
+	case 0:
+	    idx = 0;
+	    end = DOL_N_SECTIONS;
+	    break;
+
+	case 3:
+	    if (FindFirstFreeDolSection(info,dh,2))
+		return true;
+	    // fall through
+
+	case 1:
+	    idx = 0;
+	    end = DOL_N_TEXT_SECTIONS;
+	    break;
+
+	case 2:
+	    idx = DOL_N_TEXT_SECTIONS;
+	    end = DOL_N_SECTIONS;
+	    break;
+
+	default:
+	    idx = 0;
+	    end = 0;
+	    break;
+    }
+
+    while ( idx < end && ntohl(dh->sect_size[idx]) )
+	idx++;
+
+    if ( idx >= end )
+    {
+	info->section = -1;
+	return false;
+    }
+
+    info->section = idx;
+    StringCopyS(info->name,sizeof(info->name),GetDolSectionName(idx));
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool FindDolSectionBySelector
+(
+    // returns TRUE on found
+
+    dol_sect_info_t		*info,	// result
+    const dol_header_t		*dh,	// DOL header to analyse
+    const dol_sect_select_t	*dss	// DOL section selector
+)
+{
+    DASSERT(info);
+    DASSERT(dh);
+    DASSERT(dss);
+
+    if ( dss->sect_idx >= 0 )
+    {
+	memset(info,0,sizeof(*info));
+	info->section = dss->sect_idx;
+	memcpy(info->name,dss->name,sizeof(info->name));
+	return true;
+    }
+
+    return FindFirstFreeDolSection(info,dh,dss->find_mode);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u32 FindFreeSpaceDOL
+(
+    // return address or NULL on not-found
+
+    const dol_header_t	*dol_head,	// valid DOL header
+    u32			addr_beg,	// first possible address
+    u32			addr_end,	// last possible address
+    u32			size,		// minimal size
+    u32			align,		// aligning
+    u32			*space		// not NULL: store available space here
+)
+{
+    DASSERT(dol_head);
+
+    MemMap_t mm;
+    InitializeMemMap(&mm);
+
+    int i;
+    for ( i = 0; i < DOL_N_SECTIONS; i++ )
+    {
+	const u32 size = ntohl(dol_head->sect_size[i]);
+	if (size)
+	{
+	    const u32 addr = ntohl(dol_head->sect_addr[i]);
+	    if ( addr < addr_end && addr + size > addr_beg )
+	    {
+		MemMapItem_t * mi = InsertMemMap(&mm,addr,size);
+		if (mi)
+		{
+		    if ( i < DOL_N_TEXT_SECTIONS )
+			snprintf(mi->info,sizeof(mi->info),"T%u",i);
+		    else
+			snprintf(mi->info,sizeof(mi->info),"D%u",
+				i - DOL_N_TEXT_SECTIONS);
+		}
+	    }
+	}
+    }
+    //PrintMemMap(&mm,stdout,3,"section");
+
+    u64 res_space;
+    const u32 res = FindFreeSpaceMemMap(&mm,addr_beg,addr_end,size,align,&res_space);
+    ResetMemMap(&mm);
+    if (space)
+	*space = res_space;
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u32 FindFreeBssSpaceDOL
+(
+    // return address or NULL on not-found
+
+    const dol_header_t	*dol_head,	// valid DOL header
+    u32			size,		// min size
+    u32			align,		// aligning
+    u32			*space		// not NULL: store available space here
+)
+{
+    DASSERT(dol_head);
+    const u32 bss_addr = ntohl(dol_head->bss_addr);
+    const u32 bss_size = ntohl(dol_head->bss_size);
+    if ( !bss_addr || !bss_size )
+    {
+	if (space)
+	    *space = 0;
+	return 0;
+    }
+
+    return FindFreeSpaceDOL(dol_head,bss_addr,bss_addr+bss_size,size,align,space);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void DumpDolHeader
+(
+    FILE		* f,		// dump to this file
+    int			indent,		// indention
+    const dol_header_t	*dol_head,	// valid DOL header
+    uint		file_size,	// NULL or size of file
+    uint		print_mode	// bit field:
+					//  1: print file map
+					//  2: print virtual mem map
+					//  4: print delta table
+)
+{
+    DASSERT(f);
+    DASSERT(dol_head);
+
+    indent = NormalizeIndent(indent);
+
+    dol_header_t dol;
+    ntoh_dol_header(&dol,dol_head);
+
+    MemMap_t mm1, mm2, mm3;
+    InitializeMemMap(&mm1);
+    InitializeMemMap(&mm2);
+    InitializeMemMap(&mm3);
+    MemMapItem_t * mi = InsertMemMap(&mm1,0,sizeof(dol_header_t));
+    StringCopyS(mi->info,sizeof(mi->info),"DOL header");
+    if (file_size)
+    {
+	mi = InsertMemMap(&mm1,file_size,0);
+	StringCopyS(mi->info,sizeof(mi->info),"--- end of file ---");
+    }
+
+    int i;
+    for ( i = 0; i < DOL_N_SECTIONS; i++ )
+    {
+	const u32 size = dol.sect_size[i];
+	if (size)
+	{
+	    const u32 off  = dol.sect_off[i];
+	    const u32 addr = dol.sect_addr[i];
+
+	    char buf[sizeof(mi->info)], buf3[sizeof(mi->info)];
+	    if ( i < DOL_N_TEXT_SECTIONS )
+	    {
+		snprintf(buf,sizeof(buf),"text section T%u",i);
+		snprintf(buf3,sizeof(buf3),"%8x : T%u",addr-off,i);
+	    }
+	    else
+	    {
+		const int j = i - DOL_N_TEXT_SECTIONS;
+		snprintf(buf,sizeof(buf),"data section D%u",j);
+		snprintf(buf3,sizeof(buf3),"%8x : D%u",addr-off,j);
+	    }
+
+	    mi = InsertMemMap(&mm1,off,size);
+	    strcpy(mi->info,buf);
+	    mi = InsertMemMap(&mm2,addr,size);
+	    strcpy(mi->info,buf);
+	    mi = InsertMemMap(&mm3,addr,size);
+	    strcpy(mi->info,buf3);
+	}
+    }
+
+    if ( print_mode & 1 )
+    {
+	fprintf(f,"%*sMemory map of DOL file:\n\n",indent,"");
+	PrintMemMap(&mm1,f,indent+3,"section");
+	putc('\n',f);
+    }
+
+    if ( print_mode & 2 )
+    {
+	mi = InsertMemMap(&mm2,dol.bss_addr,dol.bss_size);
+	snprintf(mi->info,sizeof(mi->info),"bss section");
+	mi = InsertMemMap(&mm2,dol.entry_addr,0);
+	snprintf(mi->info,sizeof(mi->info),"entry point");
+
+	fprintf(f,"%*sMemory map of DOL image:\n\n",indent,"");
+	mm2.begin = 0xffffffff;
+	PrintMemMap(&mm2,f,indent+3,"section");
+	putc('\n',f);
+    }
+
+    if ( print_mode & 4 )
+    {
+	mm3.begin = 0xffffffff;
+	fprintf(f,"%*sDelta between file offset and virtual address:\n\n",
+		    indent,"" );
+	PrintMemMap(&mm3,f,indent+3,"   delta : section");
+	putc('\n',f);
+    }
+
+    ResetMemMap(&mm1);
+    ResetMemMap(&mm2);
+    ResetMemMap(&mm3);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int GetDolSectionAddr
+(
+    // returns dsa->section
+    dol_sect_addr_t	*dsa,		// result: section address info
+    const dol_header_t	*dol_head,	// valid DOL header
+    u32			addr,		// address to search
+    u32			size		// >0: wanted size
+)
+{
+    DASSERT(dsa);
+    DASSERT(dol_head);
+    memset(dsa,0,sizeof(*dsa));
+    dsa->addr = addr;
+    dsa->size = size;
+
+    int sect;
+    for ( sect = 0; sect < DOL_N_SECTIONS; sect++ )
+    {
+	const u32 sect_addr = ntohl(dol_head->sect_addr[sect]);
+	const u32 sect_size = ntohl(dol_head->sect_size[sect]);
+	if ( addr >= sect_addr && addr+size <= sect_addr + sect_size )
+	{
+	    dsa->sect_addr   = sect_addr;
+	    dsa->sect_offset = addr - sect_addr;
+	    dsa->sect_size   = sect_size;
+	    StringCopyS(dsa->sect_name,sizeof(dsa->sect_name),GetDolSectionName(sect));
+	    return dsa->section = sect;
+	}
+    }
+
+    //--- bss?
+
+    const u32 bss_addr = ntohl(dol_head->bss_addr);
+    const u32 bss_size = ntohl(dol_head->bss_size);
+    if ( addr >= bss_addr && addr+size <= bss_addr + bss_size )
+    {
+	dsa->sect_addr   = bss_addr;
+	dsa->sect_offset = addr - bss_addr;
+	dsa->sect_size   = bss_size;
+	StringCopyS(dsa->sect_name,sizeof(dsa->sect_name),"BSS");
+	return dsa->section = DOL_IDX_BSS;
+    }
+
+    //--- not found
+
+    return dsa->section = -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp GetDolSectionAddrInfo
+(
+    // returns GetCircBuf() or EmptyString on error
+    const dol_header_t	*dol_head,	// valid DOL header
+    u32			addr,		// address to search
+    u32			size		// >0: wanted size
+)
+{
+    DASSERT(dol_head);
+    dol_sect_addr_t dsa;
+    if ( GetDolSectionAddr(&dsa,dol_head,addr,size) < 0 )
+	return EmptyString;
+
+    return PrintCircBuf(" (%s+%#x)",dsa.sect_name,dsa.sect_offset);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u32 GetDolOffsetByAddr
+(
+    const dol_header_t	*dol_head,	// valid DOL header
+    u32			addr,		// address to search
+    u32			size,		// >0: wanted size
+    u32			*valid_size	// not NULL: return valid size
+)
+{
+    DASSERT(dol_head);
+
+    int sect;
+    for ( sect = 0; sect < DOL_N_SECTIONS; sect++ )
+    {
+	const u32 sect_addr = ntohl(dol_head->sect_addr[sect]);
+	const u32 sect_size = ntohl(dol_head->sect_size[sect]);
+	if ( addr >= sect_addr && addr < sect_addr + sect_size )
+	{
+	    u32 max_size = sect_addr + sect_size - addr;
+	    if (!size)
+	    {
+		if (valid_size)
+		    *valid_size = max_size;
+	    }
+	    else if ( size <= max_size )
+	    {
+		if (valid_size)
+		    *valid_size = size;
+	    }
+	    else if (valid_size)
+		*valid_size = max_size;
+	    else
+		return 0;
+
+	    return ntohl(dol_head->sect_off[sect]) + addr - sect_addr;
+	}
+    }
+
+    if (valid_size)
+	*valid_size = 0;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u32 GetDolAddrByOffset
+(
+    const dol_header_t	*dol_head,	// valid DOL header
+    u32			off,		// address to search
+    u32			size,		// >0: wanted size
+    u32			*valid_size	// not NULL: return valid size
+)
+{
+    DASSERT(dol_head);
+
+    int sect;
+    for ( sect = 0; sect < DOL_N_SECTIONS; sect++ )
+    {
+	const u32 sect_off  = ntohl(dol_head->sect_off[sect]);
+	const u32 sect_size = ntohl(dol_head->sect_size[sect]);
+
+	if ( off >= sect_off && off < sect_off + sect_size )
+	{
+	    u32 max_size = sect_off + sect_size - off;
+	    if (!size)
+	    {
+		if (valid_size)
+		    *valid_size = max_size;
+	    }
+	    else if ( size <= max_size )
+	    {
+		if (valid_size)
+		    *valid_size = size;
+	    }
+	    else if (valid_size)
+		*valid_size = max_size;
+	    else
+		return 0;
+
+	    return ntohl(dol_head->sect_addr[sect]) + off - sect_off;
+	}
+    }
+
+    if (valid_size)
+	*valid_size = 0;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint AddDolAddrByOffset
+(
+    const dol_header_t	*dol_head,	// valid DOL header
+    MemMap_t		*mm,		// valid destination mem map, not cleared
+    bool		use_tie,	// TRUE: use InsertMemMapTie()
+    u32			off,		// address to search
+    u32			size		// size, may overlay multiple sections
+)
+{
+    DASSERT(dol_head);
+    DASSERT(mm);
+
+    uint count = 0;
+    while ( size > 0 )
+    {
+	u32 valid_size;
+	u32 addr = GetDolAddrByOffset(dol_head,off,size,&valid_size);
+	if ( !addr || !valid_size )
+	    break;
+	if (use_tie)
+	   InsertMemMapTie(mm,addr,valid_size);
+	else
+	   InsertMemMap(mm,addr,valid_size);
+	off  += valid_size;
+	size -= valid_size;
+    }
+
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint TranslateDolOffsets
+(
+    const dol_header_t	*dol_head,	// valid DOL header
+    MemMap_t		*mm,		// valid destination mem map, not cleared
+    bool		use_tie,	// TRUE: use InsertMemMapTie()
+    const MemMap_t	*mm_off		// NULL or mem map with offsets
+)
+{
+    DASSERT(dol_head);
+    DASSERT(mm);
+    if (!mm_off)
+	return 0;
+
+    uint mi, count = 0;
+    for ( mi = 0; mi < mm_off->used; mi++ )
+    {
+	const MemMapItem_t *src = mm_off->field[mi];
+	AddDolAddrByOffset(dol_head,mm,use_tie,src->off,src->size);
+    }
+
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint TranslateAllDolOffsets
+(
+    const dol_header_t	*dol_head,	// valid DOL header
+    MemMap_t		*mm,		// valid destination mem map, not cleared
+    bool		use_tie		// TRUE: use InsertMemMapTie()
+)
+{
+    DASSERT(dol_head);
+    DASSERT(mm);
+
+    uint count = 0;
+
+    int i;
+    for ( i = 0; i < DOL_N_SECTIONS; i++ )
+    {
+	const u32 size = ntohl(dol_head->sect_size[i]);
+	if (size)
+	{
+	    count++;
+	    const u32 addr = ntohl(dol_head->sect_addr[i]);
+	    MemMapItem_t *mi = use_tie
+				? InsertMemMapTie(mm,addr,size)
+				: InsertMemMap(mm,addr,size);
+	    if (*mi->info)
+		StringCopyS(mi->info,sizeof(mi->info),"...");
+	    else if ( i < DOL_N_TEXT_SECTIONS )
+		snprintf(mi->info,sizeof(mi->info),"text section T%u",i);
+	    else
+	    {
+		const int j = i - DOL_N_TEXT_SECTIONS;
+		snprintf(mi->info,sizeof(mi->info),"data section D%u",j);
+	    }
+	}
+    }
+
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint TranslateDolSections
+(
+    const dol_header_t	*dol_head,	// valid DOL header
+    MemMap_t		*mm,		// valid destination mem map, not cleared
+    bool		use_tie,	// TRUE: use InsertMemMapTie()
+    uint		dol_sections	// bitfield of sections
+)
+{
+    DASSERT(dol_head);
+    DASSERT(mm);
+
+    dol_sect_info_t sinfo;
+    uint sect, count = 0;
+    for ( sect = 0; sect < DOL_NN_SECTIONS; sect++ )
+    {
+	if ( dol_sections & 1 << sect
+		&& GetDolSectionInfo(&sinfo,dol_head,sizeof(*dol_head),sect) )
+	{
+	    count++;
+	    uint size = sect == DOL_IDX_ENTRY ? 16 : sinfo.size;
+	    MemMapItem_t *mi = use_tie
+			    ? InsertMemMapTie(mm,sinfo.addr,size)
+			    : InsertMemMap(mm,sinfo.addr,size);
+
+	    if (*mi->info)
+		StringCopyS(mi->info,sizeof(mi->info),"...");
+	    else
+		snprintf(mi->info,sizeof(mi->info),
+			    "section %s",dol_section_name[sect]);
+	}
+    }
+
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint CountOverlappedDolSections
+(
+    // returns the number of overlapped section by [addr,size]
+
+    const dol_header_t	*dol_head,	// valid DOL header
+    u32			addr,		// address to search
+    u32			size		// size of addr to verify
+)
+{
+    DASSERT(dol_head);
+
+    u32 end = addr + size;
+    if ( end < addr ) // overflow
+	end = M1(end);
+
+    uint sect, count = 0;
+    for ( sect = 0; sect < DOL_N_SECTIONS; sect++ )
+    {
+	const u32 sect_addr = ntohl(dol_head->sect_addr[sect]);
+	const u32 sect_size = ntohl(dol_head->sect_size[sect]);
+	if ( addr < sect_addr + sect_size && end > sect_addr )
+	    count++;
+
+	noPRINT("%8x..%8x / %8x..%8x => %d/%u\n",
+	    addr, end, sect_addr, sect_addr + sect_size,
+	    addr < sect_addr + sect_size && end > sect_addr, count );
+    }
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __APPLE__
+ void * memmem ( const void *l, size_t l_len, const void *s, size_t s_len );
+#endif // __APPLE__
+
+///////////////////////////////////////////////////////////////////////////////
+
+static u32 FindDolAddress
+(
+    const u8	*data,		// DOL data beginning with dol_header_t
+    uint	off_begin,	// begin search here
+    uint	off_end,	// end search here
+    const u8	*search,	// data to search
+    uint	serach_size	// size of 'search'
+)
+{
+    while ( off_begin < off_end )
+    {
+	const u8 *res
+	    = memmem( data+off_begin, off_end-off_begin, search, serach_size );
+	if (!res)
+	    return 0;
+	off_begin = res - data;
+	if (!(off_begin&3)) // check alignment
+	    return off_begin;
+	off_begin++;
+    }
+    return 0;
+}
+
+//-----------------------------------------------------------------------------
+
+u32 FindDolAddressOfVBI
+(
+    // search in available data and return NULL if not found
+
+    cvp			data,		// DOL data beginning with dol_header_t
+    uint		data_size	// size of 'data'
+)
+{
+    if ( data_size < sizeof(dol_header_t) )
+	return 0;
+    const dol_header_t *dh = (dol_header_t*)data;
+
+    static const u8 search1[] = { 0x7C,0xE3,0x3B,0x78, 0x38,0x87,0x00,0x34,
+				  0x38,0xA7,0x00,0x38, 0x38,0xC7,0x00,0x4C };
+    static const u8 search2[] = { 0x4E,0x80,0x00,0x20 };
+
+    int sect;
+    for ( sect = 0; sect < DOL_N_SECTIONS; sect++ )
+    {
+	const u32 off1 = ntohl(dh->sect_off[sect]);
+	const u32 size = ntohl(dh->sect_size[sect]);
+	if ( !size || off1 >= data_size )
+	    continue;
+
+	u32 off_end = off1 + size;
+	if ( off_end > data_size )
+	    off_end = data_size;
+
+	u32 off2 = FindDolAddress( data, off1, off_end, search1, sizeof(search1) );
+	if (off2)
+	{
+	    off2 = FindDolAddress( data, off2+sizeof(search1), off_end,
+				search2, sizeof(search2) );
+	    if (off2)
+		return ntohl(dh->sect_addr[sect]) + off2 - off1;
+	}
+    }
+    return 0;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanDolSectionName
+(
+    // returns the first uninterpreted character
+
+    ccp			arg,		// comma/space separated names
+    int			*ret_section,	// not NULL: return section index
+					//	<0: error / >=0: section index
+    enumError		*ret_err	// not NULL: return error code
+)
+{
+    int section = -1;
+    enumError err = ERR_OK;
+
+    if (!arg)
+	err = ERR_MISSING_PARAM;
+    else
+    {
+	while ( *arg && !isalnum((int)*arg) )
+	    arg++;
+
+	ccp ptr = arg;
+	char namebuf[10], *np = namebuf;
+	for(;;)
+	{
+	    char ch = toupper((int)*ptr);
+	    if ( ch < 'A' || ch > 'Z' )
+		break;
+	    if ( np < namebuf + sizeof(namebuf) - 1 )
+		*np++ = ch;
+	    ptr++;
+	}
+
+	int index = -1;
+	if (!memcmp(namebuf,"TEXT",np-namebuf))
+	    index = 0;
+	else if (!memcmp(namebuf,"DATA",np-namebuf))
+	    index = DOL_N_TEXT_SECTIONS;
+	else
+	{
+	    if (!memcmp(namebuf,"BSS",np-namebuf))
+	    {
+		section = DOL_IDX_BSS;
+		arg = ptr;
+	    }
+	    else if (!memcmp(namebuf,"ENTRY",np-namebuf))
+	    {
+		section = DOL_IDX_ENTRY;
+		arg = ptr;
+	    }
+	    else
+		err = ERR_INVALID_DATA;
+	    goto abort;
+	}
+
+	char *end;
+	uint num = str2ul(ptr,&end,10);
+	if ( end > ptr )
+	{
+	    arg = end;
+	    index += num;
+	    if ( index < DOL_N_SECTIONS )
+		section = index;
+	    else
+		err = ERR_INVALID_DATA;
+	}
+    }
+
+ abort:;
+    if (ret_section)
+	*ret_section = section;
+    if (ret_err)
+	*ret_err = err;
+    return (char*)arg;
+}
+
+//-----------------------------------------------------------------------------
+
+uint ScanDolSectionList
+(
+    // return a bitfield as section list
+
+    ccp			arg,		// comma/space separated names
+    enumError		*ret_err	// not NULL: return status
+)
+{
+    enumError err = ERR_OK;
+    uint sect_list = 0;
+
+    while ( arg && *arg )
+    {
+	int section;
+	enumError scan_err;
+	arg = ScanDolSectionName(arg,&section,&scan_err);
+	if (scan_err)
+	{
+	    if ( err < scan_err )
+		err = scan_err;
+	    break;
+	}
+
+	if ( section >= 0 )
+	    sect_list |= 1 << section;
+    }
+
+    if (ret_err)
+	*ret_err = !sect_list && err < ERR_MISSING_PARAM ? ERR_MISSING_PARAM : err;
+    return sect_list;
+}
+
+//-----------------------------------------------------------------------------
+
+ccp DolSectionList2Text ( uint sect_list )
+{
+    char buf[100], *dest = buf;
+    uint sect;
+    for ( sect = 0; sect < DOL_NN_SECTIONS; sect++ )
+	if ( sect_list & 1 << sect )
+	    dest = snprintfE(dest,buf+sizeof(buf),",%s",dol_section_name[sect]);
+
+    char *res = GetCircBuf(dest-buf);
+    memcpy(res,buf+1,dest-buf);
+    return res;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		    add/remove DOL sections		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+
+uint CompressDOL
+(
+    // return: size of compressed DOL (inline replaced)
+
+    dol_header_t	*dol,		// valid dol header
+    FILE		*log		// not NULL: print memmap to this file
+)
+{
+    DASSERT(dol);
+
+    MemMap_t mm;
+    InitializeMemMap(&mm);
+
+    uint max_off = 0, total_data_size = 0;
+    uint s;
+    for ( s = 0; s < DOL_N_SECTIONS; s++ )
+    {
+	const u32 off  = ntohl(dol->sect_off[s]);
+	const u32 size = ntohl(dol->sect_size[s]);
+	if ( off && size )
+	{
+	    MemMapItem_t *mi = InsertMemMap(&mm,off,size);
+	    snprintf(mi->info,sizeof(mi->info),"%u",s);
+	    total_data_size += size;
+	    if ( max_off < off + size )
+		 max_off = off + size;
+	}
+    }
+
+    if (log)
+	PrintMemMap(&mm,log,5,"DOL sections");
+
+    u8 *temp = MALLOC(total_data_size);
+
+    uint i, new_off = 0;
+    for ( i = 0; i < mm.used; i++ )
+    {
+	MemMapItem_t *mi = mm.field[i];
+	uint sect = strtoul(mi->info,0,10);
+	DASSERT( sect < DOL_N_SECTIONS );
+	const u32 off  = ntohl(dol->sect_off[sect]);
+	const u32 size = ntohl(dol->sect_size[sect]);
+
+	memcpy( temp + new_off, (u8*)dol + off, size );
+	dol->sect_off[sect] = htonl( sizeof(dol_header_t) + new_off );
+	new_off += size;
+    }
+    DASSERT( total_data_size == new_off );
+
+    memcpy(dol+1,temp,new_off);
+    FREE(temp);
+    return new_off + sizeof(dol_header_t);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint RemoveDolSections
+(
+    // return: 0:if not modifed, >0:size of compressed DOL
+
+    dol_header_t	*dol,		// valid dol header
+    uint		stay,		// bit field of sections (0..17): SET => don't remove
+    uint		*res_stay,	// not NULL: store bit field of vlaid sections here
+    FILE		*log		// not NULL: print memmap to this file
+)
+{
+    uint s, m, count = 0;
+    for ( s = 0, m = 1; s < DOL_N_SECTIONS; s++, m <<= 1 )
+    {
+	const u32 off  = ntohl(dol->sect_off[s]);
+	const u32 size = ntohl(dol->sect_size[s]);
+	if ( !off || !size )
+	    stay &= ~m;
+
+	if ( !(stay&m) && off )
+	{
+	    dol->sect_off[s] = dol->sect_size[s] = dol->sect_addr[s] = 0;
+	    count++;
+	}
+    }
+
+    if (res_stay)
+	*res_stay = stay;
+
+    return count ? CompressDOL(dol,log) : 0;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			Gecko Code Handler		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool IsValidGCH
+(
+    const gch_header_t *gh,		// valid header
+    uint		file_size	// size of file
+)
+{
+    DASSERT(gh);
+
+    if ( file_size < sizeof(*gh) || ntohl(gh->magic) != GCH_MAGIC_NUM )
+	return false;
+
+    const u32 addr  = ntohl(gh->addr);
+    const u32 size  = ntohl(gh->size);
+    const u32 entry = ntohl(gh->vbi_entry);
+
+    if ( addr < 0x80000000 || sizeof(*gh) + size > file_size )
+	return false;
+
+    if ( entry && ( entry < addr || entry >= addr + size - 4 ))
+	return false;
+
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp DecodeWCH
+(
+    // returns NULL on success, or a short error message
+
+    wch_control_t	*wc,		// store only, (initialized)
+    void		*data,		// source data, modified if type != 0
+    uint		size,		// size of 'data'
+    DecompressWCH_func	decompress	// NULL or decompression function
+)
+{
+    DASSERT(wc);
+    DASSERT( data || !size );
+
+    memset(wc,0,sizeof(*wc));
+    if ( !data || size < sizeof(wch_header_t) + sizeof(wch_segment_t) )
+	return "To small for a WCH file";
+
+    const wch_header_t *wh = data;
+    wc->wh.magic   = ntohl(wh->magic);
+    wc->wh.version = ntohl(wh->version);
+    wc->wh.size	   = ntohl(wh->size);
+    if ( wc->wh.magic != WCH_MAGIC_NUM || wc->wh.version > 1 )
+	return "Invalid WCH header";
+
+    const wch_segment_t *ptr = wh->segment;
+    if ( wc->wh.version == 1 && decompress )
+    {
+	wc->temp_size = wc->wh.size;
+	wc->temp_data = MALLOC(wc->temp_size);
+	DASSERT(wc->temp_data);
+
+	uint data_size = size - sizeof(wch_header_t);
+	if ( decompress(wc,(void*)ptr,data_size) != ERR_OK )
+	    return "Decompression of WCH failed.";
+	ptr = (wch_segment_t*)wc->temp_data;
+    }
+
+    const wch_segment_t *end = (wch_segment_t*)( (u8*)ptr + wc->wh.size );
+    noPRINT("%p %p [%zd]\n",ptr,end,(u8*)end-(u8*)ptr);
+
+    uint iseg;
+    wch_segment_t *dseg = wc->seg;
+    for ( iseg = 0; iseg < WCH_MAX_SEG; iseg++, dseg++ )
+    {
+	if (!ptr->type)
+	    break;
+	dseg->type		= ntohl(ptr->type);
+	dseg->addr		= ntohl(ptr->addr);
+	dseg->size		= ntohl(ptr->size);
+	dseg->main_entry	= ntohl(ptr->main_entry);
+	dseg->main_entry_old	= ntohl(ptr->main_entry_old);
+	dseg->vbi_entry		= ntohl(ptr->vbi_entry);
+	dseg->vbi_entry_old	= ntohl(ptr->vbi_entry_old);
+
+	u8 *src_data = (u8*)ptr->data;
+	wc->seg_data[iseg] = src_data;
+	ptr = (wch_segment_t*)(ptr->data + ALIGN32(dseg->size,4));
+	if ( ptr > end )
+	{
+	    wc->is_valid = false;
+	    return "Damaged WCH data";
+	}
+    }
+    wc->n_seg = iseg;
+    memset(dseg,0,sizeof(*dseg));
+    wc->is_valid = true;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetWCH ( wch_control_t * wc )
+{
+    if ( wc && wc->temp_data )
+    {
+	FREE(wc->temp_data);
+	wc->temp_data = 0;
+	wc->temp_size = 0;
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			virtual dumps			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    E N D			///////////////
+///////////////////////////////////////////////////////////////////////////////