Revision b152aa84

b/Makefile.target
88 88
QEMU_CFLAGS+=-I$(SRC_PATH)/linux-user -I$(SRC_PATH)/linux-user/$(TARGET_ABI_DIR)
89 89
obj-y = main.o syscall.o strace.o mmap.o signal.o thunk.o \
90 90
      elfload.o linuxload.o uaccess.o gdbstub.o cpu-uname.o \
91
      qemu-malloc.o
91
      qemu-malloc.o $(oslib-obj-y)
92 92

  
93 93
obj-$(TARGET_HAS_BFLT) += flatload.o
94 94

  
b/oslib-posix.c
31 31
#include "trace.h"
32 32
#include "qemu_socket.h"
33 33

  
34
#if !defined(_POSIX_C_SOURCE) || defined(__sun__)
35
static void *oom_check(void *ptr)
34
void *qemu_oom_check(void *ptr)
36 35
{
37 36
    if (ptr == NULL) {
38 37
        fprintf(stderr, "Failed to allocate memory: %s\n", strerror(errno));
......
40 39
    }
41 40
    return ptr;
42 41
}
43
#endif
44 42

  
45 43
void *qemu_memalign(size_t alignment, size_t size)
46 44
{
......
54 52
        abort();
55 53
    }
56 54
#elif defined(CONFIG_BSD)
57
    ptr = oom_check(valloc(size));
55
    ptr = qemu_oom_check(valloc(size));
58 56
#else
59
    ptr = oom_check(memalign(alignment, size));
57
    ptr = qemu_oom_check(memalign(alignment, size));
60 58
#endif
61 59
    trace_qemu_memalign(alignment, size, ptr);
62 60
    return ptr;
b/oslib-win32.c
31 31
#include "trace.h"
32 32
#include "qemu_socket.h"
33 33

  
34
static void *oom_check(void *ptr)
34
void *qemu_oom_check(void *ptr)
35 35
{
36 36
    if (ptr == NULL) {
37 37
        fprintf(stderr, "Failed to allocate memory: %lu\n", GetLastError());
......
47 47
    if (!size) {
48 48
        abort();
49 49
    }
50
    ptr = oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
50
    ptr = qemu_oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
51 51
    trace_qemu_memalign(alignment, size, ptr);
52 52
    return ptr;
53 53
}
......
62 62
    if (!size) {
63 63
        abort();
64 64
    }
65
    ptr = oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
65
    ptr = qemu_oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
66 66
    trace_qemu_vmalloc(size, ptr);
67 67
    return ptr;
68 68
}
b/qemu-common.h
175 175
int ffs(int i);
176 176
#endif
177 177

  
178
void *qemu_oom_check(void *ptr);
178 179
void *qemu_malloc(size_t size);
179 180
void *qemu_realloc(void *ptr, size_t size);
180 181
void *qemu_mallocz(size_t size);
b/qemu-malloc.c
25 25
#include "trace.h"
26 26
#include <stdlib.h>
27 27

  
28
static void *oom_check(void *ptr)
29
{
30
    if (ptr == NULL) {
31
        abort();
32
    }
33
    return ptr;
34
}
35

  
36 28
void qemu_free(void *ptr)
37 29
{
38 30
    trace_qemu_free(ptr);
......
54 46
    if (!size && !allow_zero_malloc()) {
55 47
        abort();
56 48
    }
57
    ptr = oom_check(malloc(size ? size : 1));
49
    ptr = qemu_oom_check(malloc(size ? size : 1));
58 50
    trace_qemu_malloc(size, ptr);
59 51
    return ptr;
60 52
}
......
65 57
    if (!size && !allow_zero_malloc()) {
66 58
        abort();
67 59
    }
68
    newptr = oom_check(realloc(ptr, size ? size : 1));
60
    newptr = qemu_oom_check(realloc(ptr, size ? size : 1));
69 61
    trace_qemu_realloc(ptr, size, newptr);
70 62
    return newptr;
71 63
}
......
75 67
    if (!size && !allow_zero_malloc()) {
76 68
        abort();
77 69
    }
78
    return oom_check(calloc(1, size ? size : 1));
70
    return qemu_oom_check(calloc(1, size ? size : 1));
79 71
}
80 72

  
81 73
char *qemu_strdup(const char *str)

Also available in: Unified diff