heap.c

pocket pc hx4700 bootloader

/****************************************************************************/
/* Copyright 2000 Compaq Computer Corporation.                              */
/*                                           .                              */
/* Copying or modifying this code for any purpose is permitted,             */
/* provided that this copyright notice is preserved in its entirety         */
/* in all copies or modifications.  COMPAQ COMPUTER CORPORATION             */
/* MAKES NO WARRANTIES, EXPRESSED OR IMPLIED, AS TO THE USEFULNESS          */
/* OR CORRECTNESS OF THIS CODE OR ITS FITNESS FOR ANY PARTICULAR            */
/* PURPOSE.                                                                 */
/****************************************************************************/
/*
 *
 * Some small changes to adopt code to bootloader
 * Copyright 2005,2006 by Pawel Kolodziejski
 */

#define BLOCKHEAD_SIGNATURE 0x0000F00D

typedef long Int32;
typedef char Bool;
#define NULL 0
#define TRUE (1 == 1)
#define FALSE (0 == 1)

typedef struct blockhead_t {
  Int32 signature;
  Bool allocated;
  unsigned long size;
  struct blockhead_t *next;
  struct blockhead_t *prev;
} blockhead;

int malloc_init(void) {
  blockhead *gHeapBase = (blockhead *)(0xA3900000);
  gHeapBase->allocated=FALSE;
  gHeapBase->signature=BLOCKHEAD_SIGNATURE;
  gHeapBase->next=NULL;
  gHeapBase->prev=NULL;
  gHeapBase->size = 0x700000 - sizeof(blockhead); // 7 MB heap size

  return 0;
}

void *malloc(unsigned long size) 
{
  blockhead *blockptr = (blockhead *)(0xA3900000);
  blockhead *newblock;
  Bool compacted = FALSE;

  size = (size+7)&~7; /* unsigned long align the size */
  while (blockptr != NULL) {
    if (blockptr->allocated == FALSE) {
      if (blockptr->size >= size) {
	blockptr->allocated=TRUE;
	if ((blockptr->size - size) > sizeof(blockhead)) {
	  newblock = (blockhead *)((unsigned char *)(blockptr) + sizeof(blockhead) + size);
	  newblock->signature = BLOCKHEAD_SIGNATURE;
	  newblock->prev = blockptr;
	  newblock->next = blockptr->next;
	  newblock->size = blockptr->size - size - sizeof(blockhead);
	  newblock->allocated = FALSE;
	  blockptr->next = newblock;
	  blockptr->size = size;
	} else {
	}
	break;
      }
      else {
	if ((blockptr->next == NULL) && (compacted == FALSE)) {
	  if (compact_heap()) {
	    compacted=TRUE;
	    blockptr = (blockhead *)(0xA3900000);
	    continue;
	  }
	}
      }
    }
    blockptr = blockptr->next;
  }
  return (blockptr != NULL) ? ((unsigned char *)(blockptr)+
			       sizeof(blockhead)) : NULL;
}

int compact_heap() {
  // return non-zero if heap was compacted
  return 0;
}

void free(void *block) {
  blockhead *blockptr;

  if (block == NULL) return;

  blockptr = (blockhead *)((unsigned char *)(block) - sizeof(blockhead));


  if (blockptr->signature != BLOCKHEAD_SIGNATURE) return;

  blockptr->allocated=FALSE;
  return;
}