void * mbed_urealloc(void * ptr, size_t bytes, UAllocTraits_t traits)
{
void * caller = (void*) caller_addr();
void *newptr = NULL;
if (ptr == NULL) {
return mbed_ualloc(bytes, traits);
}
if(traits.flags & ~UALLOC_TRAITS_BITMASK) {
// Traits not supported in urealloc yet
ualloc_debug(UALLOC_DEBUG_WARNING, "ua c:%p fail\n", caller);
return NULL;
}
uintptr_t ptr_tmp = (uintptr_t) ptr;
if ((ptr_tmp < (uintptr_t) mbed_sbrk_ptr) &&
(ptr_tmp >= (uintptr_t)&__mbed_sbrk_start)) {
newptr = dlrealloc(ptr, bytes);
} else {
ualloc_debug(UALLOC_DEBUG_LOG, "uf c:%p m:%p non-heap realloc\n", caller, ptr);
}
if(newptr == NULL) {
ualloc_debug(UALLOC_DEBUG_WARNING, "ur c:%p m0:%p fail\n", caller, ptr);
} else {
ualloc_debug(UALLOC_DEBUG_LOG, "ur c:%p m0:%p m1:%p\n", caller, ptr, newptr);
}
return newptr;
}
void * mbed_ualloc(size_t bytes, UAllocTraits_t traits)
{
void * ptr = NULL;
void * caller = (void*) caller_addr();
if (UALLOC_TEST_TRAITS(traits.flags, UALLOC_TRAITS_NEVER_FREE)) {
ptr = mbed_krbs(bytes);
// krbs uses the same semantics as sbrk, so translate a -1 to NULL.
if (ptr == (void*)-1) {
ptr = NULL;
}
if ((ptr != NULL) && UALLOC_TEST_TRAITS(traits.flags, UALLOC_TRAITS_ZERO_FILL)) {
memset(ptr, 0, bytes);
}
} else if (UALLOC_TEST_TRAITS(traits.flags, UALLOC_TRAITS_ZERO_FILL)) {
ptr = dlcalloc(1, bytes);
} else if (!(traits.flags & ~UALLOC_TRAITS_BITMASK)) {
ptr = dlmalloc(bytes);
} else if (traits.flags & UALLOC_RESERVED_MASK) {
ualloc_debug(UALLOC_DEBUG_ERROR, "ua c:%p reserved: %lx\n", caller,
traits.flags & UALLOC_RESERVED_MASK);
}
if(ptr == NULL) {
ualloc_debug(UALLOC_DEBUG_WARNING, "ua c:%p fail\n", caller);
} else {
ualloc_debug(UALLOC_DEBUG_LOG, "ua c:%p m:%p\n", caller, ptr);
}
return ptr;
}
void mbed_ufree(void * ptr)
{
void * caller = (void*) caller_addr();
ualloc_debug(UALLOC_DEBUG_LOG, "uf c:%p m:%p\n", caller, ptr);
uintptr_t ptr_tmp = (uintptr_t) ptr;
if ((ptr_tmp < (uintptr_t) mbed_sbrk_ptr) &&
(ptr_tmp >= (uintptr_t)&__mbed_sbrk_start)) {
dlfree(ptr);
} else {
ualloc_debug(UALLOC_DEBUG_LOG, "uf c:%p m:%p non-heap free\n", caller, ptr);
}
}
BOOLEAN bpact()
{
register BPINFO *p;
BPINFO *prev, *next;
BOOLEAN found;
ADDRESS oldpc;
delayed = NONE;
found = FALSE;
prev = NIL;
for (p = bphead; p != NIL; p = next) {
next = p->bpnext;
if (p->bpaddr == pc) {
prbpfound(p);
found = TRUE;
if (p->bpcond == NIL || isswitch(p->bptype) || cond(p->bpcond)) {
prbphandled();
if (handlebp(p) == NOSAVE) {
prbpnosave();
if (prev == NIL) {
bphead = next;
} else {
prev->bpnext = next;
}
dispose(p);
} else {
prbpsave();
prev = p;
}
} else {
prev = p;
}
} else {
prev = p;
}
}
if (delayed != NONE) {
oldpc = pc;
runtofirst();
if ((delayed&DELAY_CALL) == DELAY_CALL) {
SYM *s, *t;
s = curfunc;
t = whatblock(return_addr());
if (t == NIL) {
panic("can't find block for caller addr %d", caller_addr());
}
printcall(s, t);
addbp(return_addr(), RETURN, s, NIL, NIL, 0);
}
if (pc != oldpc) {
bpact();
}
if (isstopped) {
printstatus();
}
} else {
if (isstopped) {
printstatus();
}
}
fflush(stdout);
return(found);
}
